ACM总结 - 动态规划 - 第六周

最新推荐文章于 2023-04-17 00:24:29 发布

千鱼干

最新推荐文章于 2023-04-17 00:24:29 发布

阅读量111

点赞数

分类专栏：笔记文章标签：算法动态规划数据结构

本文链接：https://blog.csdn.net/qq_25426559/article/details/115821174

版权

笔记专栏收录该内容

13 篇文章 3 订阅

订阅专栏

好题儿

贪心与动态规划相结合（C题）

根据题目的意思，老鼠的体重要递增，而老鼠的速度要递减。刚开始以为是对两个数组求最大不下降子序列。通过对两个数组（体重、速度）求LCS后，找出相同的下标个数，就是所求的那一组数据的下标和，再输出这些下标不就行了吗。但是后来发现了一个一个问题：这些数据并不是按照顺序输入的，也就是说，要先进行排序才可以。
这时就想到了用贪心算法：以weight为第一元素从小到大排序，以speed为第二元素从大到小。此时的状态转移方程为：

$d p [i] = 1$ ；//因为只有一个数据时要有值，所以dp初始值设置为1

$\max(dp[i], dp[j] + 1)$ ;

$(j < i, p [j] . w e i g h t > p [i] . w e i g h t, p [j] . s p e e d < p [i] . s p e e d)$ ;//对i进行降序循环，对j进行初始值为i的升序循环，找出满足体重升速度减的元素。
代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

struct node{
    int weight;
    int speed;
    int num;
}p[10010];

int dp[10010];

bool cmp(node A,node B){
    if(A.weight != B.weight) return A.weight < B.weight;
    else return A.speed > B.speed;
}

int main(){
    int k = 1, x, y;
    while(scanf("%d%d", &x, &y) != EOF){
        p[k].weight = x;
        p[k].speed = y;
        p[k].num = k;
        k++;
    }
    sort(p + 1, p + k + 1, cmp);
    int ans = 0;
    for(int i = k; i >= 1; i--){
            dp[i] = 1;
        for(int j = i; j <= k; j++){
            if(p[j].weight > p[i].weight && p[j].speed < p[i].speed){
                dp[i] = max(dp[i], dp[j]+1);
            }
        }
        ans = max(ans, dp[i]);
    }
    printf("%d\n", ans);
    for(int i = 1; i <= k; i++){
        if(dp[i] == ans){
            printf("%d\n", p[i].num);
            ans--;
        }
        if(ans == 0) break;
    }
	return 0;
}

G两种方式

这一题和常见的求吃金币的不一样，这一题是求走到终点的方案数。这一题可以反过来运用动态规划，有点类似《算法笔记》里的数塔问题，也就是记忆化搜索，就是从终点开始进行计算，设置终点值为1，搜索过程中记录每一点的值。此外，还可以通过正常的方式，从起始点开始，每走一格就枚举出能到达终点的所有情况。
注意，每次运行需要对p数组清零，也就是memset一下。注意memset最好只是对初始化为0或-1的数组运用，对初始化为其他数的数组最好用fill。
这里运用第二种方法，也就是比较常用的“正向动态规划”。
代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int dp[111][111], a[111][111];

int main(){
    int c, i, j, n, m, x, y, di, dj, t;
    scanf("%d", &c);
    while(c--){
        scanf("%d %d", &n, &m);
        for(i = 1; i <= n; i++) for(j = 1; j <= m; j++) scanf("%d",&a[i][j]);
        memset(dp, 0, sizeof(dp));
        dp[1][1] = 1;
        for(i = 1; i <= n; i++){
            for(j = 1; j <= m; j++){
                if(dp[i][j]){
                    t = a[i][j];
                    for(x = 0; x <= t; x++){
                        for(y = 0; y <= t; y++){
                            if(x + y == 0) continue; if(x + y > t) break;
                            di = x + i; dj = y + j;
                            if(di <= n && dj <= m) dp[di][dj] += dp[i][j];
                            dp[di][dj] %= 10000;
                        }
                    }
                }
            }
        }
        printf("%d\n", dp[n][m] % 10000);
    }    
    return 0;
}

此外我在网上找到了某博主写的第一种方法的代码：


#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
#define N 105
const int mod=10000;
int n,m;
int a[N][N];
int mark[N][N];
int dfs(int x,int y)
{
    if(mark[x][y]!=-1)
        return mark[x][y];
    int t,x1,y1,tmp;
    tmp=0;
    t=a[x][y];
    for(x1=0;x1<=t;x1++)
    {
        if(x+x1>=n)
            break;
        for(y1=0;x1+y1<=t;y1++)
        {
            if(y+y1>=m)
                break;
            if(x1+y1!=0)          //不能原地走
                tmp+=dfs(x+x1,y+y1);
        }
    }
    tmp%=mod;
    return mark[x][y]=tmp;
}
int main()
{
    int i,j,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                scanf("%d",&a[i][j]);
                mark[i][j]=-1;
            }
        }
        mark[n-1][m-1]=1;
        printf("%d\n",dfs(0,0));
    }
    return 0;
}

S题的奇妙思路

这一题提交了好多次才通过，算是比较难得了。思路不亚于前两个题。
这题也就是说疲劳度与左右手重量差有关，也就是说让小红豆最轻松，我们就要让他所有次数左右手的重量差平方和最小。
那么我们可以按照重量对物体进行排序，然后选取重量相邻的两个物体来进行比较。
设f[i][j]为前i件物品组成k对的话，所消耗的体力最小；
这时分两种情况：含有第i件物品和不含有第i件物品（第i件物品是不是含在第j对里）
1.含有i件物品，则有 $f [i] [j] = f [i - 2] [j - 1] + (v a l [i] - v a l [i - 1]) * (v a l [i] - v a l [i - 1])$
2.不含第i件物品，则有 $f [i] [j] = f [i - 1] [j]$
所以动态转移方程为: $f[i][j]=\min(f[i-2][j-1]+(val[i]-val[i-1])*(val[i]-val[i-1]), f[i][j]=f[i-1][j])$
代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

#define INF 0xfffffff

int list[2001];
int dp[1001][2001];

int main(){
	int n, k, i, j;
	while(scanf("%d%d", &n, &k) != EOF){
		for(i = 1; i <= n; i++) cin >>list[i];
		sort(list + 1, list + n + 1);
		for(i = 1; i <= n; i++) dp[0][i] = 0;
		for(i = 1; i <= k; i++){
			for(j = 2 * i; j <= n; j++){
				if(j > 2 * i) dp[i][j] = dp[i][j - 1];
				else dp[i][j] = INF;
				if(dp[i][j] > dp[i - 1][j - 2] + (list[j] - list[j - 1]) * (list[j] - list[j - 1])) dp[i][j] = dp[i - 1][j - 2] + (list[j] - list[j - 1]) * (list[j] - list[j - 1]);
			}
		}
		cout << dp[k][n] << endl;
	}
	return 0;
}

总结

这一周以刷题为主，题目还是比较困难的。不过其中有规律性的东西，比如上面三个，贪心与动态规划结合之类的，只要掌握了，基本上就OK了。难题儿还是比较多的，其实题儿练多了就不难了，期待下一周的背包。

千鱼干

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ACM总结 - 动态规划 - 第六周

目录好题儿贪心与动态规划相结合（C题）G两种方式S题的奇妙思路总结好题儿贪心与动态规划相结合（C题）根据题目的意思，老鼠的体重要递增，而老鼠的速度要递减。刚开始以为是对两个数组求最大不下降子序列。通过对两个数组（体重、速度）求LCS后，找出相同的下标个数，就是所求的那一组数据的下标和，再输出这些下标不就行了吗。但是后来发现了一个一个问题：这些数据并不是按照顺序输入的，也就是说，要先进行排序才可以。这时就想到了用贪心算法：以weight为第一元素从小到大排序，以speed为第二元素从大到小。此时的状态
复制链接

扫一扫