JavaScript|LeetCode|动态规划/BFS|279.完全平方数

法1：动态规划
想法：

1. 数组dp保存当n = 1, 2, 3, ……时，将n分割成多个完全平方数的 完全平方数个数（最少个数）
2. 如果 i 是完全平方数，则dp[i] = 1
3. 如果 i 不是完全平方数，则dp[i] = min{dp[i], dp[i - j] + dp[j]}：将 i 分为两部分（j = 1 ~ i - 1），各部分可能也会被分割，但：动态规划无需考虑如何来，只需考虑结果如何（只需考虑dp[i - j] 和 dp[j] 的值）；又可能之前的分割得到的dp[i]更小，则dp[i]不变
4. 找的是dp[i]的最小值，故dp[i]预值为n，最多由n个完全平方数组成（全是1）

/** 
* @param {number} n 
* @return {number} 
*/
var numSquares = function(n) {    
    var dp = [];    
    var i = 0; j = 0;    
    for(i = 0; i <= n; i++) {        
        dp[i] = n; // n个1相加    
    }    
    dp[1] = 1;    
    for(i = 2; i <= n; i++) {        
        if(Math.sqrt(i) == Math.floor(Math.sqrt(i))) {            
            // 这个数本身是完全平方数            
            dp[i] = 1;            
            continue;        
        }        
        for(j = 1; j < i; j++) {            
            dp[i] = Math.min(dp[i], dp[i - j] + dp[j]);        
        }    
    }    
    return dp[n];
};

法2：BFS
想法：

1. 将 0~n 这 n + 1 个整数作为节点，若任意两数 i 和 j 之间的差值的绝对值是完全平方数，则节点 i 和节点 j 之间有边
2. 本题需要求解：从节点 n 到节点 0 的最短路径长度（即经过最少的完全平方数个数）
   注：已经访问的节点需要做标记，使用marked数组

/** 
* @param {number} n 
* @return {number} 
*/
var numSquares = function(n) {    
    var length = 0, output = 0, marked = [], node = [];    
    var i = 0;    
    for(i = 0; i <= n; i++) {        
        marked[i] = false; // 该节点未访问    
    }
    node[0] = n; // 从节点n出发，目标是节点0    
    marked[n] = true;    
    while(node.length > 0) { // 当node中还有节点时        
        // length表示当前层的节点个数        
        // 同层节点与起点距离相同        
        length = node.length;         
        while(length > 0) {            
            if(Math.sqrt(node[0]) == Math.floor(Math.sqrt(node[0]))) {                
                // 如果当前节点就是一个完全平方数，则找到最近的路径                
                output++;                
                return output;            
            }            
            for(i = node[0] - 1; i > 0; i--) {                
                if(marked[i]) {                    
                    continue;                
                }                
                if(Math.sqrt(node[0] - i) == Math.floor(Math.sqrt(node[0] - i))) {
                    // 两数差值是完全平方数                    
                    marked[i] = true;                    
                    node.push(i);                
                }            
            }            
            node.shift(); // 与这个节点相邻的节点已经找到并且加入            
            length--;        
        }        
        output++; // 当前层已经遍历完成，路径 + 1    
    }    
    return output;
};