1、动态规划专题

最新推荐文章于 2022-07-25 15:52:18 发布
最新推荐文章于 2022-07-25 15:52:18 发布
阅读量262 收藏
点赞数
分类专栏： 实习笔试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39804483/article/details/88902138
版权

（1）将数组分成值相等两部分 

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

//递归
int final = 0;
bool b = false;
bool f(vector<int> v, int i,int fool,int sum)
{
	if ( i== v.size())
	{
		return false;
	}
	if (fool ==1)
	{
		sum += v[i];
	}
	//sum += v[i]
	if (sum == final)
	{
		b = true;
		return true;
	}
	
	f(v, i + 1, 0, sum);
	f(v, i + 1, 1, sum);

}
bool func(vector<int> v)
{
	int sum = 0;
	for (int i =0 ; i < v.size(); i++)
	{
		sum +=v[i];
	}
	if (sum %2 ==1)
	{
		return false;
	}
	const int all = sum / 2;//背包总重量
	const int  inum = v.size();
	vector<vector<int>> dp(inum + 1,vector<int>(all+1,0));
	for (int i =1; i <=inum; i++)
	{
		for (int j =1; j <= all; j++)
		{
	//		cout << v[i - 1];
			if (j < v[i-1])//包里装不下这个物品
			{
				dp[i][j] = dp[i - 1][j];
			}
			else
			{
				//包里可以装下这个物品
				dp[i][j] = max(dp[i - 1][j],dp[i -1][j - v[i - 1]] + v[i - 1]);
			}
		}
	}
	
	if (dp[inum][all] ==all )
	{
		return true;
	}
	return false;
}

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(5);
	int sum = 0;
	final = 7;
	f(v, -1, 0, sum);
	cout << b << endl;

	cout << func(v)<<endl;
	system("pause");
	return 0;
}

（2）堆积木问题

#include <iostream>
#include <limits.h>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

// every block has 3 choice

struct block
{
    block(int x, int y, int z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
        
    }
    int x, y, z;
};

bool comp(const block& a, const block& b) //
{
    if (a.x == b.x)//
        return a.y > b.y;
    return a.x > b.x;
}

int T, ans;
//int index;
int DP[200];//记录最大高度

void DP_TR(vector<block> BK)//构造DP表
{
   int index =4;
    int i, j;
    for (i = 0; i <index; ++i)
    {
        DP[i] = BK[i].z;
        for (j = 0; j < i; ++j)
        {
            if (BK[i].x < BK[j].x && BK[i].y < BK[j].y)//如果j号块比i号块的截面大，则将i号放在j号上面，更新高度
                DP[i] = max(DP[i], DP[j] + BK[i].z);
        }
    }
    cout << DP[index - 1] << endl;
}
int main()
{
   
    
    return 0;
}

 （3）走台阶问题

int recur(int n)
{
    if(n == 1)
        return 1;
    if (n == 2)
    {
        return 2;
    }
    return recur(n - 1) + recur(n - 2);
}
int getCount(int n)
{
    int sum =0;
    if (n == 1)
    {
        return 1;
    }
    if (n == 2)
    {
        return 2;
    }
    int a = 1;
    int b=  2;
    for (int i = 3; i <=n; i++)
    {
        sum  = a +b;
        a = b;
        b =sum;
    }
    return sum;
}

（4）硬币找零问题--（最少需要的硬币数量）

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

class Solution {
public:
    ;
    /**
     * @param coins: a list of integer
     * @param amount: a total amount of money amount
     * @return: the fewest number of coins that you need to make up
     */
    int coinChange(vector<int> &coins, int amount) {
        // write your code here
        sort(coins.begin(), coins.end());//排序是必要的 为了后面处理1
        int *dp = new int[amount +1];
        fill(dp,dp+amount + 1, 0);//初始化
        if ( amount <= 0) {
            return 0;//如果钱数小于0 一定是0种方法
        }
        if(coins.size() == 0)//如果数组长度是0，对于钱数大于0的值来说，一定没有
            return -1;
        for (int i =0; i<=amount; i++)//
        {
            if(coins[0] != 0)//
            {
                if (i%coins[0] ==0)
                {
                    dp[i] = i/coins[0];
                }
                else
                    dp[i] = INT_MAX;
            }
            else
            {
                if(coins.size() >1)
                {
                    if (i%coins[1] ==0)
                    {
                        dp[i] = i/coins[1];
                    }
                    else
                        dp[i] = INT_MAX;
                }
                else
                    return -1;
            }
        }
        for (int i =1; i <coins.size(); i++)
        {
            for (int j =coins[i]; j <=amount; j++)
            {
                if (dp[j - coins[i]] != INT_MAX)
                {
                    dp[j] = min(dp[j],dp[j - coins[i]] + 1);
                }
            }
        }
        
        if(dp[amount] == INT_MAX)
            return -1;
        else
            return dp[amount];
        
    }
};

（5）挖矿问题

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

const int W = 10;
const int number = 5;
const int VALUE[] = { 500, 200, 300, 350, 400 };
const int WEIGHT[] = { 5, 3, 4, 3, 5 };


//function Make( i {处理到第i件物品} , j{剩余的空间为j}) :integer;
int Make(int i, int j)
{
	int r = 0;
	if (i == -1)
	{
		return 0;
	}
	if (j >= WEIGHT[i])   //背包剩余空间可以放下物品 i  
	{
		r =   max(Make(i - 1, j - WEIGHT[i]) + VALUE[i], Make(i - 1, j));
	}
	return r;
	
}
int getGold(int n, int w)
{
	int pr[1000];
	for (int i =0 ; i <= n; i++)
	{
		if (i < WEIGHT[0])//背包重量
		{
			pr[i] = 0;
		}
		else
			pr[i] = VALUE[0];
	}
	for (int i =1; i <= n; i++)
	{
		for (int j =W ; j >=WEIGHT[i]; j--)//背包重量
		{
				pr[j] = max(pr[j], pr[j - WEIGHT[i]] + VALUE[i]);
		}
	}
	return pr[w];
}
void main()
{
	int maxValue = Make(number - 1, W);
	cout << "maxValue: " << maxValue << endl;
	cout << getGold(5,10);
	system("pause");
}

(6)硬币找零

#include <iostream>

using namespace std;
long long dp[10001] = {1};//特别注意
const int w[] = { 1, 5, 10, 25, 50 };
int getCount()
{
     for (int i = 0; i < 5; i++)
        for (int j = w[i]; j <= 10000; j++)
            dp[j] += dp[j - w[i]];//不用这个硬币 用这个硬币
    int money =0;
    while(cin>> money)
    cout  << dp[money]<<endl;
return 0;
}
//方法二用二维数组来做
int dps[5][10001] ={1}; 
int getCount_()
{
    int money =0;
    for(int i =0; i <5; i++)
        dps[i][0] = 1;
  for(int i =0 ; i< 5; i++)
  {
      for(int j =w[i]; j <= 10000; j++)
      {
          dps[i][j] = dps[i][j] + dps[i][j -w[i]];
       }
  }
   while(cin>> money)
    cout  << dps[4][money]<<endl;
return 0;
}
int main()
{
    getCount();
    return 0;
}

修改版本

//
//  main.cpp
//  dprogram
//
//  Created by 吴珝君 on 2019/4/2.
//  Copyright © 2019年 闲着也是贤者. All rights reserved.
//

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
/*
 （1）从台阶问题的例子出发
 有一座n级台阶，从下往上走，每跨一步向上1级或者2级台阶。请求出一共有多少种走法。
 思路: 假如有10级台阶，则0-9级的走法数量+ 0-8级的走法数量
 */
int type[5] = {1,5,10,25,50};
int dp[1000]={0};
int  getCount(int sum)
{
    
    for (int i =0; i<=sum; i++)
    {
        if (i%type[0] ==0)
        {
            dp[i] = 1;
        }
        else
            dp[i] = 0;
    }
    for (int i =1; i <5; i++)
    {
        for (int j =type[i]; j <=sum; j++)
        {
            if (dp[j - type[i]] != 65535)
            {
                dp[j] = dp[j]+dp[j - type[i]];
            }
        }
    }
    
    if(dp[sum] == 65535)
        return -1;
    else
        return dp[sum];
}

    int main(int argc, const char * argv[])
    {
    // insert code here...

        cout << getCount(11)<<endl;
    return 0;
}

（7）硬币问题：一个硬币只使用一次

int  getCount_(int sum)
{
    
    for (int i =0; i<=sum; i++)
    {
        if (i == type[0])
        {
            dp[i] = 1;
        }
        else
            dp[i] = 0;
    }
    for (int i =1; i <5; i++)
    {
       for (int j = sum; j >=type[i]; j--)//之所以要反着来是因为其依赖得是上一行的值。如果不反着来的话，相当于我先将当前值修改了给后面的值用，这样就变成了依赖于当前行，矛盾，因而要反过来。
        {
            if (dp[j - type[i]] != 65535)
            {
                dp[j] = dp[j]+dp[j - type[i]];
            }
        }
    }
    
    if(dp[sum] == 65535)
        return -1;
    else
        return dp[sum];
}

（8）0-1背包问题

int weight[5] = {2,2,4,6,3};
int value[5] ={3,4,8,9,6};
int  getMin(int all)
{
    int res[5][100] ={0};//保存所有状态
    //边界条件
    for(int i =0 ; i <= all; i++)
    {
        if (i <weight[0])
        {
            res[0][i] = 0;
        }
        else
            res[0][i] = value[0];
    }//最多一个物品能够达到的装袋
    for (int i = 1; i < 5; i++)
    {
        for (int j = 0; j <= all; j++)
        {
            if ( j < weight[i])
            {
                res[i][j] = res[i -1][j];
            }
            else
            {
                res[i][j] = max(res[i -1][j] , res[i -1][j - weight[i]] + value[i] );
            }
        }
        
      
    }
    
    int j = all;
    for (int i = 4; i>=1; i--)
    {
        if (j - weight[i]>=0 && res[i -1][j - weight[i]] >0)
        {
            cout <<"---->" << weight[i];
            j = j - weight[i];
        }
    }
    if(j != 0)
    {
        cout <<"----->" <<weight[0] << endl;
    }
   
  return res[4][all];
    
}

（9）杨辉三角

//杨辉三角
int triangle(vector<vector<int>> v)
{
    for (int i = 3; i >=0 ; i--)
    {
        for (int j =0; j <= i; j++)
        {
            v[i][j] = v[i][j] + min(v[i+1][j],v[i + 1][j+1]) ;
            cout <<" i " << i << "j "<<j <<" " << v[i][j] << endl;
        }
    }
    
    cout << v[0][0]<< endl;
    return 0;
}

（10）最长公共子序列

//dp问题
int  getmax(vector<int> arr)
{
    
    int *longest = new int[arr.size()];
    fill(longest,longest+arr.size() , 0);
    int len =arr.size();
    for (int i=0; i<len; i++)
        longest[i] = 1;
    
    for (int j=1; j<len; j++)//所有需要匹配的子串
    {
        for (int i=0; i<j; i++)//已经匹配的元素
        {
            //j是待比较的元素 i是已经获得的子序列中的最后一个元素 如果比最后一个元素还大  说明这个也是递增的
            if (arr[j]>arr[i] && longest[j]<longest[i] +1)//
            { //注意longest[j]<longest[i]+1这个条件
                longest[j] = longest[i] + 1; //计算以arr[j]结尾的序列的最长递增子序列长度
            }
            
        }
    }
    
    sort(longest, longest + arr.size());
    return longest[arr.size() - 1];
}

（8）最短编辑距离与最长递增子序列

#include<iostream>
#include<string>
#include<vector>
#include <algorithm>
using namespace  std;
int getMax(vector<int> can, vector<int> child)
{
	sort(can.begin(), can.end());
	sort(child.begin(), child.end());
	int count = 0;
	int j = 0;
	for (int i = 0; i < child.size(); i++)
	{
		while (j < can.size())
		{
			if (child[i] <= can[j])
			{
				count++;
				j++;
				break;
			}
			j++;
		}
	}
	return count;
}

int dp[100] = { 1 };
//从左向右扫描，找出连续的非严格递增串，删除最后一个
int LIS(vector<int> str)
{
	if (str.empty()){
		return 0;
	}
	for (int i = 0; i < str.size(); i++)
	{
		for (int  j = i +1; j < str.size(); j++)
		{
			if (str[i] < str[j])
			{
				dp[j] = max(dp[j], dp[i] +1);
			}
		}
	}

	int m = 0;
	for (int i = 0; i < str.size(); i++)
	{
		if (m < dp[i])
		{
			m = dp[i];
		}
	}
	return m;
		
}
long long total[1000];
int main()
{
	vector<int> v;
	srand(NULL);
	for (int i = 0; i < 20; i++)
	{
		int T =rand() % 10;
		cout << T << " ";
		v.push_back(T);

	}
	cout << endl;
	cout << LIS(v);


	
	system("pause");
	return 0;
}

 

吴珝君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划（0-1背包）---划分数组为和相等的两部分
weixin_30826095的博客
07-02 2557
划分数组为和相等的两部分 416. Partition Equal Subset Sum (Medium) 题目描述：   给定一个数组，判断其是否可以被划分为相等的两部分。 思路分析：   我们可以换一种思路，判断其是否可以分为相等的两部分，其实就是看是否能在数组中挑选出和为数组和一半的序列。那么就可以转化为背包问题，在N个数中挑选数字使其和为数组和的一半，状态转移方程为：   dp[i]=dp...
动态规划-将数组分成两个数组,并最小化数组和的差(java)
SP_1024的博客
06-13 731
每到一个数,有选择和不选两种情况,分开讨论,返回最逼近sum/2 的最大值.尽量让两个集合的累加和接近 返回最接近的情况下，较小集合的累加和。我们先求出数组的累加和sum.然后拆分数组时,让较小集合去逼近。给定一个正数数组arr， 请把arr中所有的数分成两个集合，sum/2.这样得出的数组就是符合要求的.动态规划就是对递归的改写,还是三个步骤.1.根据base case 初始化dp表。2.递归过程改成从表中拿数据的过程。3.返回递归调用的最初始状态。
破解大厂算法面试最难动态规划题:将数组分割成元素和相等的两部分
tyler_download的专栏
03-08 2340
算法面试最难题型：通过动态规划分割数组
分割数组为和相等的两个子数组
warriorsword的博客
03-12 4896
在正数数组确定分界点，使得分界点两边的子数组和相等。例如：数组为【1,5,3,2,4】，则分界点为3，1+5=2+4。 java实现代码如下： class Solution{ public boolean div(int[] a){ int i=0,j=a.length-1;//i指向前边子数组尾，j指向后边子数组的头。i,j初始时分别指向原数组首尾 int m,n; ...
将一个数组划分成总和相等的两部分
a524633094的博客
03-19 7304
题目： 判断给定的一个数组，是不是可以分成两个数组之和相等的数组 Example： [1,2,6,3]可以分成[1,2,3]和[6] 算法：动态规划 class Solution(object): def canPartition(self, nums): """ :type nums: List[int] :rtype: bool ...
动态规划专题之斐波那契数列1
08-08
算法4利用斐波那契数列递推公式的特性，只保留了每个元素的当前值和它前面的2个元素值，对计算过程中产生的子问题解用过即弃，所需空间较少，但每次求解新元素的值，都需
动态规划专题之多重背包问题1
08-08
int MultiPack_3(int n, int c) { //cur[j]表示给定i个物品的情况下，背包容量为j时，对物品进行第k次选择时所能获得的最优
动态规划专题之合并石子问题1
08-08
len代表当前被合并在一起的石子堆的数量，算法的思想是先计算所有相邻的2堆石子合并在一起的解，再计算所有所有相邻的3堆石子合并在一起的解，逐步扩大子问题的规模。
动态规划专题之最长公共子序列1
08-08
动态规划系列专题讲义专题三：最长公共子序列/* Name: 动态规划专题之最长公共子序列 Author: 巧若拙 Description: 1808_公共子序列
算法竞赛专题解析--动态规划优化(1)四边形不等式1
08-04
《算法竞赛入门到进阶》的第 7 章“动态规划”，讲解了 DP 的概念，以及线性 DP、区间DP、树形 DP、数位 DP、状态压缩 DP 等应用场景。本文以及后续
算法20--数组分成长度相等两个数组，使两部分和最接近
大魔王
11-11 6027
给定一个数组，长度为偶数，将数组分成长度相等两部分，使两部分和最接近 先介绍01背包，然后解决长度可以不相等的情况，最后解决该问题 问题0: 01背包问题---k件商品，每件都有重量wi以及价格vi,给定一个袋子容量为W,求袋子中存放商品价值最大的取货方案 令f(k,w)为袋里可用容量为w时，取前k件商品的最大总价值 若已知f(k-1,w)，求出f(k,w)：第k件商品重量为wk,价格...
【Leetcode】416. 分割等和子集
Greenary的博客
02-23 633
题目链接：分割等和子集 题目描述：给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 思路：将数组分割成两个等和的子集。 那么： 1）数组元素的和肯定得是偶数，并且数组长度必须大于1。 2）问题转换为：数组中是否存在若干个元素，其和为数组所有元素和的一半。即寻找若干元素的和为target。 本来的思路是：将元素排序，然后使用回溯的方法，通过了100多个样例。剩下几个样例错误，经过反复思考和尝试发现回溯的方法并不对。 于是看了
Leetcode 416. 分割等和子集 C++
weixin_43750513的博客
07-06 488
Leetcode 416. 分割等和子集 题目 给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200 测试样例 示例 1: 输入: [1, 5, 11, 5] 输出: true 解释: 数组可以分割成 [1, 5, 5] 和 [11]. 示例 2: 输入: [1, 2, 3, 5] 输出: false 解释: 数组不能分割成两个元素和相等的子集. 题解 根据题意可以知道，如果数组的和
【Leetcode HOT100】分割等和子集 c++
mie haha
07-25 465
分割等和子集：给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
LeetCode 分割整数数组，分割为两部分的和相等
司曹龙的博客
03-22 6222
/*! * @file 数组分割.cpp * @Date: 2018/03/22 15:03 * @author: sicaolong * @Contact: sicaolong@163.com * @brief: 将数组分割成两部分，两部分的和相等的部分；判断是否存在这样的分割 思路1:递归：1、先求出这个数组的和， 2、看这个和能不能被2整除，可以的话再进行...
拆分正整数数组，使二者和最接近，且长度相等。
wangche320的专栏
07-04 1144
/** * 一个 正整数数组，长度为2n，将它分成两个数组，长度均为n，使得这两个数组的和最接近。 * * 思路： * 记原数组的元素和为sum，从2n个元素中挑出n个，使得其和最接近并且小于等于sum/2。 * * 动态规划 * 结果集必然以某一个数结尾，所以可以枚举每一个元素。 * 在每一次枚举过程中，以该元素k结尾，然后看是否可以在前k-1找到i-1个数，使得它们之和等于
判断一个数组，是否可以分成两个数组之和相等的数组
热门推荐
线上幽灵
09-06 1万+
题目： 判断给定的一个数组，是不是可以分成两个数组之和相等的数组 Example： [1,2,6,3]可以分成[1,2,3]和[6] 解析： 此题可以用0,1背包问题来解决，分成的两个数组之和，一定为整个数组之和的一半，所以将背包容量设为初始数组之和的一半即可，最后在判断背包所装的容量是不是整个数组之和的一半。 代码： #include &lt;iostream&...
561.[leetcode]C++实现数组拆分1（Array Partition I）
guaiguaitinghua的博客
06-06 766
（一）题目描述 （二）思想方法 让相近的数在一起取最小值，才能使最终的和最大。 （三）代码实现 class Solution { public: int arrayPairSum(vector<int>& nums) { int sum = 0; sort(nums.begin(), nums.end()); for (int i...
789. 数的范围
qq_43885462的博客
05-16 274
二分模板 **查找左端点** bool check(int x) {/* ... */} // 检查x是否满足某种性质 // 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用： int bsearch_1(int l, int r) { while (l < r) { int mid = l + r >> 1; if (check(mid)) r = mid; // check()判断mid是否满足性质
基于动态规划的目标优化分配决策模型
最新发布
07-25
- *2* *3* [DP动态规划专题（一）动态规划基本模型](https://blog.csdn.net/qq_33945246/article/details/88966823)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值