2023NEUQACM Week4

Clarus_Xie

已于 2023-11-11 18:47:54 修改

阅读量68

点赞数 1

分类专栏： NEUQACM 文章标签：算法 c++ 数据结构

于 2023-11-05 12:19:07 首次发布

本文链接：https://blog.csdn.net/2301_79207651/article/details/134228612

版权

NEUQACM 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

必做题

B3637 最长上升子序列

递推，把答案存在另一个数组里，用空间换时间。
完整代码如下：

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

int arr[5003];
int kage[5003];
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	int n,ans=0; cin>>n;
	for(int i=0 ; i<n ; i++) cin>>arr[i];
	for(int i=0 ; i<n ; i++){
		for(int j=0 ; j<i ; j++)
		{
			if(arr[i]>arr[j]){
				kage[i] = max(kage[i], kage[j]+1);
				ans = max(ans, kage[i]);
			}
		}
	}
	cout << ans+1;
	return 0;
}

P1115 最大子段和

把答案存在另一个数组里。
完整代码如下：

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

int a[200005];
int b[200005];
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	int n; cin>>n;
	for(int i=0 ; i<n ; i++) cin>> a[i];
	b[0] = a[0]; int ans = a[0];
	for(int i=1 ; i<n ; i++) b[i] = max(a[i], a[i]+b[i-1]);
	for(int i=1 ; i<n ; i++) ans = max(ans, b[i]);
	cout << ans;
	return 0;
}

P8707 [蓝桥杯 2020 省 AB1] 走方格

直接在原二维数组上递推，省空间。
完整代码如下：

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

int arr[35][35];
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	int n,m;
	cin>>n>>m;
	for(int i=1 ; i<=n ; i++) arr[i][1] = 1;
	for(int i=1 ; i<=m ; i++) arr[1][i] = 1;
	int r = min(n,m);
	for(int i=2 ; i<=r ; i++){
		if(i%2) arr[i][i] = arr[i-1][i] + arr[i][i-1];
		for(int j=i+1 ; j<=m ; j++) 
			if(i%2 || j%2) arr[i][j] = arr[i][j-1] + arr[i-1][j];
		for(int k=i+1 ; k<=n;  k++)
			if(i%2 || k%2) arr[k][i] = arr[k][i-1] + arr[k-1][i];
	}
	cout << arr[n][m];
	return 0;
}

P1216 [USACO1.5] [IOI1994]数字三角形 Number Triangles

从下往上推。
完整代码如下：

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

int arr[1003][1003];
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	int r; cin>>r;
	for(int i=1 ; i<=r ; i++)
		for(int j=1 ; j<=i ; j++) cin>>arr[i][j];
	for(int i=r-1 ; i>=1 ; i--)
		for(int j=1 ; j<=i ; j++)
			arr[i][j] += max(arr[i+1][j], arr[i+1][j+1]);
	cout << arr[1][1];	
	return 0;
}

P1020 [NOIP1999 普及组] 导弹拦截

思路：使用 vector 和二分查找算法来求解最长递增子序列（LIS）和最长非递减子序列（LNDS）的长度。

实现：
对于LNDS：
维护一个动态规划数组res1，将 $n$ 个导弹扫一遍。
如果新的导弹小于等于res1.back()，push；
反之则更新res1，将该导弹放到合适的位置，因为是非递减，可以重复，使用upper_bound。
对于LIS：
同样维护一个动态规划数组res2，将 $n$ 个导弹扫一遍。
如果新的导弹大于res2.back()，push；
反之则更新res2，将该导弹放到合适的位置，因为是严格递增，不可以重复，使用lower_bound。
在最后，只要读取res1和res2的长度即可。
完整代码如下：

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

vector<int> arr(1e5+5), res1, res2;
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	int n=0;
	while(cin>>arr[n]) n++;
	res1.push_back(arr[0]);
	for(int i=1 ; i<n ; i++){
		if(arr[i] <= res1.back()) res1.push_back(arr[i]);
		else{
			int pos = upper_bound(res1.begin(), res1.end(), arr[i], greater<int>()) - res1.begin();
			res1[pos] = arr[i];
		}
	}
	res2.push_back(arr[0]);
	for(int i=1 ; i<n ; i++){
		if(arr[i] > res2.back()) res2.push_back(arr[i]);
		else{
			int pos = lower_bound(res2.begin(), res2.end(), arr[i]) - res2.begin();
			res2[pos] = arr[i];
		}
	}	
	cout << res1.size() << '\n' << res2.size();
	return 0;
}

选做题

AT_dp_f LCS

完整代码如下：

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

int d[3005][3005];
vector<char> c;
int main()
{
	// freopen("D:\\test.txt","r",stdin);
	string s,t;
    cin>>s>>t;
    int row=s.size(), col=t.size();
    for(int i=0 ; i<row ; i++){
        for(int j=0 ; j<col ; j++){
            d[i+1][j+1] = max(d[i][j+1],d[i+1][j]);
            if(s[i]==t[j]) d[i+1][j+1] = max(d[i+1][j+1],d[i][j]+1);
        }
    }
    while(d[row][col]>0){
        if(s[row-1] == t[col-1]){
                c.push_back(s[row-1]);
                row--, col--;
        }
        else{
            if(d[row][col] == d[row-1][col]) row--;
            else col--;
        }
    }
    for(auto i = c.rbegin() ; i!=c.rend() ; i++) cout << *i;
    return 0;
}

P2196 [NOIP1996 提高组] 挖地雷

思路：先用dp数组递推得到最大地雷数，再根据dp数组反推路径。
完整代码如下：

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

int mine[25],dp[25],path[25][25];
int n,ans,k;
void trail(int a)
{
    cout << a << " ";
    if(a>=n) return ; // illustrate there is no need to find another mine
    int val=0, k=0;
    for(int i=n ; i>a ; i--){
        if(path[a][i]){
            val = max(val, dp[i]);
            if(val==dp[i]) k=i;
        }
    }
    if(k==0) return ; // illustrate you can never find another mine
    trail(k);
}
int main()
{
    cin>>n;
    for(int i=1 ; i<=n ; i++) cin>> mine[i];
    for(int i=1;  i<n ; i++)
        for(int j=i+1 ; j<=n ; j++) cin>>path[i][j];
    for(int i=1 ; i<=n ; i++) dp[i] = mine[i];
    for(int i=n-1 ; i>0 ; i--)
        for(int j=i+1 ; j<=n ; j++)
            if(path[i][j]) dp[i] = max(dp[i], dp[j]+mine[i]); // we find the max mine number
    for(int i=n ; i>0 ; i--){
        ans = max(ans,dp[i]);
        if(ans==dp[i]) k=i;
    }
    trail(k); // to find the trail of mining
    cout << '\n' << ans;
    return 0;
}

P1541 [NOIP2010 提高组] 乌龟棋

常规dp，可以理解为01背包问题，开一个四维数组即可

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

int dp[45][45][45][45], card[5], squ[355];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=0 ; i<n ; i++) cin>>squ[i];
    for(int i=0 ; i<m ; i++){
        int k; 
        cin>>k;
        ++card[k];
    }
    dp[0][0][0][0] = squ[0];
    for(int a=0 ; a<=card[1] ; a++)
        for(int b=0 ; b<=card[2] ; b++)
            for(int c=0 ; c<=card[3] ; c++)
                for(int d=0 ; d<=card[4] ; d++){
                    int tmp = a+b*2+c*3+d*4;
                    if(a) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a-1][b][c][d]+squ[tmp]);
                    if(b) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b-1][c][d]+squ[tmp]);
                    if(c) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b][c-1][d]+squ[tmp]);
                    if(d) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b][c][d-1]+squ[tmp]);
                }
    cout << dp[card[1]][card[2]][card[3]][card[4]];         
    return 0;
}

P2679 [NOIP2015 提高组] 子串

分析：

首先，对于初始化，当 $m = k = 0$ 的时候，无论 $n$ 是多少，答案都是 $1$ 。
然后，写出状态转移方程。
最后，考虑优化空间复杂度，用^1的方式构造滚动数组。
完整代码如下：

#include<bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n,m,k,roll=1;
char A[1005], B[205];
// int dp[1005][205][205][2];
int dp[2][205][205][2];
int main()
{
    // freopen("D:\\test.txt","r",stdin);
    cin>>n>>m>>k>>A+1>>B+1;
    dp[1][0][0][0] = dp[0][0][0][0] = 1;
    for(int i=1 ; i<=n ; i++,roll^=1){ 
        for(int j=1 ; j<=m ; j++){
            for(int p=1 ; p<=k ; p++){
                if(A[i]==B[j]){
                    dp[roll][j][p][0] = (dp[roll^1][j][p][1] + dp[roll^1][j][p][0])%mod;
                    dp[roll][j][p][1] = (dp[roll^1][j-1][p][1] + (dp[roll^1][j-1][p-1][0] + dp[roll^1][j-1][p-1][1])%mod)%mod;
                }
                else{
                    dp[roll][j][p][0] = (dp[roll^1][j][p][1] + dp[roll^1][j][p][0])%mod;
                    dp[roll][j][p][1] = 0;
                }
            }
        }
    }
    cout << (dp[roll^1][m][k][1] + dp[roll^1][m][k][0])%mod;
    return 0;
}