算法学习：递归搜索与动态规划 笔记合集

N皇后8皇后

//其实就是一个典型的深度优先搜索
//N皇后，8皇后的问题，主要就是皇后每一行只允许存在一个，而且皇后斜方向不允许同时存在
//所以循环递归每一行，然后每一行都于前面的皇后进行冲突比较，有冲突的情况就不递归
function queen(a, cur) {
    if (cur == a.length) { console.log(a); return };
    for (var i = 0; i < a.length; i++) {
        //对比前面的每一个
        a[cur] = i; flag = true;
        for (var j = 0; j < cur; j++) {
            var ab = i - a[j];//这里主要是斜冲突
            if (a[j] == i || (ab > 0 ? ab : -ab) == cur - j) { flag = false; break };
        };
        if (flag) { queen(a, cur + 1) };
    };
};

 

 

买卖股票问题

 

一、买卖股票的最佳时机 I

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。

示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
分析：
动态规划，dp记录这一步的包含之前的最小值，以及最小值后面的最大值

 

 

二、买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
分析：可以直接一次遍历，把后一项大于前一项时，两者差值相加即可。

 

三、买卖股票的最佳时机 III

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [3,3,5,0,0,3,1,4]
输出: 6
解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1] 
输出: 0 
解释: 在这个情况下, 没有交易完成, 所以最大利润为 0。
 

状态机+动态规划：

假如，i表示第几天，k表示投资几次，那么dp[i][j]总有两种状态，持有第j支股票，和卖出第j只股票后的empty状态。

必须是这两种状态，不然就不叫dp[i][j]了。

持有状态可以由持有状态转换而来，也可以由空状态转换而来。

空状态同理。

公式与解释：

0表示空

1表示持仓

状态转移方程：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

通用代码

var maxProfit = function (prices) {
    let n = prices.length;
    let max_k = 2;
    let dp = []//new int[n][max_k + 1][2];
    for (let i = -1; i < n; i++) {
        dp[i] = [];
        for (let j = 0; j < (max_k + 1); j++) {
            dp[i][j] = [];
            for (let k = 0; k < max_k; k++) {
                dp[i][j][k] = 0;
            }
        }
    }
    for (let i = 0; i < n; i++) {
        for (let k = max_k; k >= 1; k--) {
            if ((i - 1) == -1) { /*处理 base case */
                dp[i][k][0] = 0;
                dp[i][k][1] = - prices[i];
            } else {
                dp[i][k][0] = Math.max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
                dp[i][k][1] = Math.max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);
            }
        }
    }
    // 穷举了 n × max_k × 2 个状态，正确。
    // console.log("打印结果", dp);
    return dp[n - 1][max_k][0];
};

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/yi-ge-tong-yong-fang-fa-tuan-mie-6-dao-gu-piao-wen/这个地方的第一条解答有详细解答

 

Floyd算法

Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法

转发的别人的

https://www.cnblogs.com/wangyuliang/p/9216365.html

e[i][j]表示的是从i号顶点到j号顶点之间的路程。

1号顶点做中转的情况下，任意两点之间的最短路程更新为：

比如e[3][2]=9 这个白色的9，就是上上图的e[3][1]+e[1][2] = 7 + 2;

//经过1号顶点
for(i=1;i<=n;i++)  
for(j=1;j<=n;j++)  
if (e[i][j] > e[i][1]+e[1][j])  e[i][j]=e[i][1]+e[1][j];  

同理：

只允许经过1和2号顶点的情况下，任意两点之间的最短路程更新为：

把1-4全部中转一下，得出的dp表格就是各点到各点的最短距离