2024 CSP暑期集训营地 -入门DP&线性DP -晚测

• 测评题单

T1-4652 最大子段和

#include<bits/stdc++.h>
using namespace std;


const int N = 2e5+10;
int n, ans;
int f[N];

int main(){
	cin >> n;
	for(int i=1, x;i<=n;i++)
    {
        cin >> x;
        f[i] = max( x,f[i-1]+x );
        ans = max( f[i], ans);
    }
    cout << ans << endl;
    
    return 0;
}

T2-5152 地下管道

#include<bits/stdc++.h>
using namespace std;
int n,m;
int f[25][25];

int main() {
	cin >> n >> m;
    f[0][1] = 1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            f[i][j] = f[i-1][j] + f[i][j-1];
        }
    }
    cout << f[n][m] << endl;
    
  return 0;
}

T3-5223 守望者的逃离

#include<bits/stdc++.h>
using namespace std;

const int N = 3e5+10;
int f[N];
int M,S,T;

int main(){
    // 魔法、总距离、时间
    cin >> M >> S >> T;
	for(int i=1;i<=T;i++){
       if( M>=10 ){ // 优先使用魔法行走
           f[i] = f[i-1] + 60;
           M-=10;
       } 
        else{
            f[i] = f[i-1];
            M += 4;
        }
    }    
    // 休息f[i]、还是行走f[i-1]+17更加合适
    for(int i=1;i<=T;i++){
        f[i] = max( f[i],f[i-1]+17 );
    }
    // 是否能够在T时间内逃出总距离S
    for(int i=1;i<=T;i++){
        if( f[i] >= S ){
            cout << "Yes" << endl;
            cout << i << endl;
            return 0;
        }
    }
    // 逃不出，时间从后往前找，逃出的最远距离
    cout << "No" << endl;
    cout << f[T] << endl;
    return 0;
}

T4-2786 走路回家

#include<bits/stdc++.h>
using namespace std;

// 计数类 线性dp
const int N = 35;
int n, m, f[N][N]; // f[i][j]:第i次传球落到同学j中的方案种数

int main() {
	cin >> n >> m;
	// 初始化，传球 0 次，落位到同学 0 的方案种数是 1。
	f[0][0] = 1; // 同学编号 0~n，方便处理 第一个同学和最后一个同学的传导
	for (int i = 1; i <= m; i++) // 枚举传球次数
		for (int j = 0; j < n; j++) // 枚举传到位置
			f[i][j] = ( f[i - 1][(j + 1) % n] + f[i - 1][(j + n - 1) % n] ); // (j-1) < (j) > (j+1) 
	cout << f[m][0] << endl;
	return 0;
}

T5-2786 走路回家

这道题的大意是要从地图的 (1,1) 点起，走到 (n,n) 点，要求不能走在草堆上，并且转弯不能超过 k 次，求有多少种可行的方案。

很明显，这是一道 搜索题。我们可以在 dfs 函数中定义四个参数：x，y，t，way ，分别表示当前的行、当前的列、当前转弯次数 和 方向（0 代表往右走，1 代表往下走）。代码如下：

int T,n,k,a[100][100];
int dfs(int x,int y,int t,int way)
{
	int sum=0;
	if(t>k||a[x][y])//如果转弯次数超过k次，或者该点是个草堆
		return 0;
	if(x==n&&y==n)//如果到达终点，方案数加一
		return 1;
	if(x<n && !a[x+1][y])
		sum+=dfs(x+1,y,way?t:t+1,1);//往右走
    
	if(y<n&&!a[x][y+1])
		sum+=dfs(x,y+1,way?t+1:t,0);//往下走
    
	return sum;
}
int main()
{
	T=read();
	while(T--)
	{
		n=read(),k=read();
		char chr;
		for(int i=1;i<=n;i++)//输入地图
		{
			for(int j=1;j<=n;j++)
			{
				chr=getchar();
				if(chr=='.')
					a[i][j]=0;
				else
					a[i][j]=1;
			}
			chr=getchar();
		}
		printf("%d\n",dfs(1,2,0,0)+dfs(2,1,0,1));
	}
	return 0;
}

额，这就 90 分, TLE 了。

我们会发现：在 dfs 的求解过程中，有许多重复的子问题。

记忆化搜索能很好的解决这种问题：开一个 四维数组，如果之前没有求解过该状态的，就把该状态的方案数记录下来。以后如果遇到同样的状态的话，就可以直接返回该状态的方案数了。

并且，在开始的时候，我们要把整个记忆化数组初始化为 −1。代码如下：

#include <bits/stdc++.h>
using namespace std;

// P7995 [USACO21DEC] Walking Home B
// dfs+记忆化搜索

// 状态表示mem[i][j][k][q]，i,j为当前坐标、k为目前使用步数，q为当前转向(0下、1右)
int mp[55][55];
int mem[55][55][55][4];
int T, n, k;
char tmp;

// 坐标、转向次数，当前转向
int dfs(int x, int y, int t, int way)
{
    // 超出步数、当前不可行
    if (t > k || mp[x][y])
        return 0;
    // 记忆化
    if (mem[x][y][t][way] != -1)
        return mem[x][y][t][way];
    // 方案
    int sum = 0;
    if (x == n && y == n)
        return 1;
    // 向下走
    if (x + 1 <= n && !mp[x + 1][y])
        sum += dfs(x + 1, y, way ? t : t + 1, 1);
    // 向右走
    if (y + 1 <= n && !mp[x][y + 1])
        sum += dfs(x, y + 1, way ? t + 1 : t, 0);
    // 记忆
    mem[x][y][t][way] = sum;
    return sum;
}

int main()
{
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &n, &k);
        memset(mem, -1, sizeof mem);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                cin >> tmp;
                // .是可行
                if (tmp == '.')
                    mp[i][j] = 0;
                else
                    mp[i][j] = 1;
            }
        }
        // 起点->终点总方案数 = （右边点+下边点）的到达的方案数。
        printf("%d\n", dfs(1, 2, 0, 0) + dfs(2, 1, 0, 1));
    }
    return 0;
}