LeetCode: 279. 완전 제곱수(귀속사상,DP해결)

정수 n을 정하고 완전한 제곱수 몇 개를 찾아라. (예: 1, 4, 9, 16,...) 그것들의 합은 n과 같다.너는 완전한 제곱수의 개수를 최소화해야 한다.
예1:
입력: n = 12 출력: 3 설명: 12 = 4 + 4 + 4.예2:
입력: n = 13 출력: 2 해석: 13 = 4 + 9.
[사고방식] dp문제는 사실 귀속문제이다. 나는 사실 동적 기획이라는 명사를 말하는 것을 매우 싫어한다. 왜냐하면 사람들에게 매우 난해하고 이해하기 어려운 느낌을 주기 때문이다.동규의 문제는 내가 좋아하면 순귀속의 문제로 하고 dp사상을 운용하여 함수의 최적화를 수조로 대체하면 된다.그러니까 dp는 고찰귀속사상이야!
이 문제를 우리는 귀속적인 사유로 생각한다.왜냐하면 하나의 정수 n을 몇 개의 완전 제곱수의 합으로 나누어야 하기 때문이다. 그래서 나는 단번에 생각했다. 예를 들어 f(12) = min{f(12 - 1), f(12 - 4), f(12 - 9)} 그러면 우리가 매번 n보다 작은 완전 제곱수를 찾아내면 되지 않겠는가?
그래서 나는 하나의 tag 그룹을 사용하여 n보다 작은 완전 제곱수의 tag 값을 모두 내가 1로 표시했다.이런 색인 사상을 이용하면 한 수가 완전 제곱수인지 아닌지를 신속하게 판단할 수 있다!
반복 프로그램은 쉽게 쓸 수 있다.

class Solution {
public:
    int tag[10000];
    
    void findnum(int n)
    {
        for(int i = 1;i * i <= n;i++)
        {
            tag[i * i] = 1;             //       
        }
    }
    
    int f(int n)
    {
        if(n == 1)                      //  
        {
            return 1;
        }
        else
        {
            if(tag[n] == 1)             //         
                return 1;
            else
            {
                int min_res = 0x3f3f3f3f;
                for(int i = 1;i * i <= n;i++)       //              ，  i * i
                {
                    if(tag[i * i] == 1)             //        
                    {
                        int res = f(n - i * i);     //     
                        if(res + 1 < min_res)
                            min_res = res + 1;   
                    }
                }
                return min_res;
            }
        }
    }
    
    int numSquares(int n) {
        findnum(n);                     //   ，          
        return f(n);
    }
};

자, 이제 우리는 귀속 프로그램을 다 썼습니다. 이 프로그램은 반드시 시간을 초과할 것입니다. 우리는 dp수조를 이용하여 중간에 계산된 결과를 저장하여 중복 계산을 피하면 됩니다. 이것이 바로 동적 기획이 가속화되는 사상입니다.그러면 우리는 이 귀속 프로그램에 맞추어 사실 컴퍼스 프로그램도 쉽게 쓸 수 있다
AC 코드:

class Solution {
public:
    int tag[10000];
    int dp[10000];
    
    void findnum(int n)
    {
        for(int i = 1;i * i <= n;i++)
        {
            tag[i * i] = 1;             //       
        }
    }
    
    int DP(int n)
    {
        dp[1] = 1;                      //        
        for(int i = 2;i <= n;i++)
        {
            if(tag[i] == 1)
            {
                dp[i] = 1;
            }
            else
            {
                int min_res = 0x3f3f3f3f;
                for(int j = 1;j * j <= i;j++)
                {
                    if(tag[j * j] == 1)
                    {
                        int res = dp[i - j * j];
                        if(res + 1 < min_res)
                            min_res = res + 1;
                    }
                }
                dp[i] = min_res;
            }
        }
        return dp[n];
    }
    
    int numSquares(int n) {
        findnum(n);                     //   ，          
        return DP(n);
    }
};

그래서 정말 그렇습니다. 규범을 움직이는 문제는 순수하게 돌아가는 문제로 생각하고 dp는 최적화 수단일 뿐입니다.이렇게 하면 다시는 규칙을 적용하는 문제가 매우 어렵다고 느끼지 않을 것이다.만약 상태 이동 방정식을 생각하지 못했기 때문에 이 dp문제를 풀지 못했다면, 귀속 사유가 아직 부족하다고 말할 수 있을 뿐, 귀속 문제를 많이 연습해야 한다.