蓝桥杯备赛（day2）

1.KMP算法

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

题目链接

经典KMP算法，进行字符串匹配，YYDS

class Solution {
public:
    vector<int> getNext(string tstr)
    {
        int i=1, pre_len=0;
        vector<int> next;
        next.push_back(0);
        while(i<tstr.length())
        {
            if(tstr[i]==tstr[pre_len])
            {
                i++;
                pre_len++;
                next.push_back(pre_len);
            }
            else
            {
                if(!pre_len)
                {
                    i++;
                    next.push_back(pre_len);
                }
                else
                {
                    pre_len = next[pre_len-1];
                }   
            }
        }

        return next;
    }

    int strStr(string haystack, string needle) {
        vector<int> next = getNext(needle);


        int judge = -1;
        int i=0, j=0;

        while(i<haystack.length())
        {
            if(haystack[i]==needle[j])
            {
                i++;
                j++;
            }
            else
            {
                if(j>0)
                {
                    j = next[j-1];
                }
                else
                {
                    i++;
                }
            }

            if(j == needle.length())
            {
                judge = i-j;
                break;
            }
        }

        return judge;
    }
};

 2.一大群背包问题来袭

1. 问能否能装满背包（或者最多装多少）：

dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])

2. 问装满背包有几种方法：

    

dp[j] += dp[j - nums[i]]

3. 问背包装满最大价值

dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

4. 问装满背包所有物品的最小个数：

dp[j] = min(dp[j], dp[j - coins[i]] + 1)

2.1 01背包

实现一个算法求解 01 背包问题。背包问题的介绍如下:
已知一个容量为 total.eight 的背包，有不同重量不同价值的物品，问怎样在背包容量限制下达到利益最大化。.·01背包问题要求每个物品只有一个，可以选择放入或者不放入包。背包问题求解方法的介绍如下:
·用符号 : 表示第讠个物品的价值，W;表示第讠个物品的体积，V,表示当前背包容量为j时，前i个物品最佳组合对应的价值。
对于当前第之个商品，如果包的容量比该物品体积小，即讠< W;。那么此时的价值与前i-1个的价值是一样的，即 Vi=-1,j。
对于当前第之个商品，如果包的容量能够装下该物品，即 W;<”。此时需要判断装或者不装这个物品的价值对比，选择使价值更大的情况，即 ;= max(V +И-1.i-㎡,V-1.j)。
通过最优解回溯法找到解的组成:
·当 .= V-1.;时，说明没有选择第讠个物品。
·当 .i= K-1.i-㎡ 时，说明装了第讠个商品。
·从i，j的最大值一直遍历到 i=0，则找到了所有解。
输入描述
第一行为两个数字 total..eight、N，均不超过 1000。total..eight 含义见题干，N 为物品数量接下来 N 行，每行两个数字 W、亿，均不超过 1000。含义见题干。

题目链接

头有点大，下列递推公式是关键

  dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

看到一个博主总结的就很不错：

        这里需要对参数进行一些解释，是我在看的过程中所遇到的困惑，i表示的就是从0-i中选取物品，而不是选取物品的数量，可能包含第i件物品，也有可能不包含，具体要看是否是最大值的，即我们max函数的作用了。
        j表示的就是背包的大小，而不是此时背包的剩余容量。
        对于max第一个参数，比较好理解，就是不放第i个物品的情况
        max第二个参数，先看j-weight[i]，可以理解为“为了存放第i件物品，而腾出weight[i]的空间”，为何用dp[i-1][j-weight]，而不是dp[i][j-weight]呢，原因是后者对于第i件物品是否存在于背包中的情况是不知道的(注意这块，和后面的完全背包问题有关系)，而前者是确定第i件物品肯定不在包内，现在要放入第i件物品，就加上value[i]。
        上面也只是我个人的理解，这只是二维的情况

二维完整代码如下：

#include <iostream>
#include <vector>
using namespace std;

int tmax(int a, int b)
{
  return a>b?a:b;
}

int main()
{
  vector<vector<int>> dp;
  vector<int> weight, val;
  int wbag, num, tmp;

  cin >> wbag >> num;

  for(int i=0;i<num;i++)
  {
    cin >> tmp;
    weight.push_back(tmp);

    cin >> tmp;
    val.push_back(tmp);
  }

  //初始化数组
  for(int i=0;i<num;i++)
  {
    vector<int> vtmp(wbag+1, 0);
    dp.push_back(vtmp);
  }

  for(int j=0;j<dp[0].size();j++)
  {
    if(weight[0] <= j)
    {
      dp[0][j] = val[0];
    }
  }


  //更新dp
  for(int i=1;i<num;i++)
  {
    for(int j=1;j<dp[0].size();j++)
    {
      if(weight[i] > j)    //放不下了
      {
        dp[i][j] = dp[i-1][j];    
      }
      else
      {
        dp[i][j] = tmax(dp[i-1][j], dp[i-1][j-weight[i]]+val[i]);
      }
    }
  }
	
  cout << dp[dp.size()-1][dp[0].size()-1];    //输出最后一个元素
  return 0;
}

二维是如何转化到一维的？

 

  dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

        观察迭代式，可以发现，在更新dp数组的时候，只需要知道第i-1层，就可以计算出i层，理论上只要两层就够了 ，能否在精简一点呢？
        倘若要变为一层，则需要在对[i][j]进行计算的时候，[j]之前的元素，即序号<j的元素不变即可，那么我们原本从上到下、从左到右（先物品后背包，背包从小到大），就要转变为从右到左（先物品后背包，背包从大到小），改变循环顺序即可。

 一维代码如下：

#include <iostream>
#include <vector>
using namespace std;

int tmax(int a, int b)
{
  return a>b?a:b;
}

int main()
{
  
  vector<int> weight, val;
  int wbag, num, tmp;

  cin >> wbag >> num;
  vector<int> dp(wbag+1, 0);

  for(int i=0;i<num;i++)
  {
    cin >> tmp;
    weight.push_back(tmp);

    cin >> tmp;
    val.push_back(tmp);
  }

  //初始化数组
  for(int j=0;j<dp.size();j++)
  {
    if(weight[0] <= j)
    {
      dp[j] = val[0];
    }
  }


  //更新dp
  for(int i=1;i<num;i++)
  {
    for(int j=dp.size()-1;j>=weight[i];j--)
    {
        dp[j] = tmax(dp[j], dp[j-weight[i]]+val[i]);
    }
  }
	
  cout << dp[dp.size()-1];
  // 请在此输入您的代码
  return 0;
}

2.2 完全背包

题目如下：

当物品的数量为无限的时候，又该如何解决呢？

题目链接

01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。
而完全背包的物品是可以添加多次的，所以要从小到大去遍历

这是什么原理呢？
这就不得不提到2.1中的红字了，其实从小到大遍历，就相当于max当中的行数是[i]而不是[i-1]，那么此时是无法确定第i件物品是否存在于背包中的情况是不知道的（具体加没有加，其实不重要，因为我们是可以重复加的），也就是说加了也无所谓，之后max函数选择最优情况。

#include <iostream>
#include <vector>
using namespace std;

int tmax(int a, int b)
{
  return a>b?a:b;
}

int main()
{
  
  vector<int> weight, val;
  int wbag, num, tmp;

  cin >> wbag >> num;
  vector<int> dp(wbag+1, 0);

  for(int i=0;i<num;i++)
  {
    cin >> tmp;
    weight.push_back(tmp);

    cin >> tmp;
    val.push_back(tmp);
  }

  //初始化数组
  for(int j=0;j<dp.size();j++)
  {
    if(weight[0] <= j)
    {
      dp[j] = val[0];
    }
  }


  //更新dp
  for(int i=1;i<num;i++)
  {
    for(int j=weight[i];j<dp.size();j++)
    {
        dp[j] = tmax(dp[j], dp[j-weight[i]]+val[i]);
    }
  }
	
  cout << dp[dp.size()-1];
  // 请在此输入您的代码
  return 0;
}

2.3 分割等子串

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 100

题目链接

这里把元素大小看作重量，此时dp中存放的就是重量了，之后根据迭代式即可

class Solution {
public:

    int tmax(int a, int b)
    {
        return a>b?a:b;
    }

    bool canPartition(vector<int>& nums) {
        int sum = 0;

        for(int i=0;i<nums.size();i++)
        {
            sum += nums[i]; 
        }

        if(sum%2)
        {
            return false;
        }

        sum /= 2;

        vector<int> dp(sum+1, 0);

        for(int i=0;i<nums.size();i++)
        {
            for(int j=dp.size()-1;j>=nums[i];j--)
            {
                dp[j] = tmax(dp[j], dp[j-nums[i]]+nums[i]);

                if(dp[j] == sum)
                {
                    return true;
                }
            }
        }

        return false;
    }
};