AtCode DP专练A-P

最新推荐文章于 2024-07-11 09:27:54 发布
最新推荐文章于 2024-07-11 09:27:54 发布
阅读量818 收藏 15
点赞数 13
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/madtry/article/details/137128137
版权

链接：Educational DP Contest - AtCoder

A - Frog 1

题意：有n个石头，从1石头出发，每次可以跳一格或者俩格，代价为俩个格子间的高度差

思路：对于第i个石头，可以从石头i-1和i-2得到，比较一下代价即可

f[i]=max(f[i-1]+abs(h[i]-h[i-1),f[i-2]+abs(h[i]-h[i-2])

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e6+7;



void solve()
{
    int n;
    cin>>n;
    vector<int> a(n);
    for(int &x:a){
        cin>>x;
    }
    vector<int> f(n,1e9);
    f[0]=0;
    for(int i=1;i<n;i++){
        if(i-1>=0){
            f[i]=min(f[i-1]+abs(a[i]-a[i-1]),f[i]);
        }
        if(i-2>=0){
            f[i]=min(f[i],min(f[i-1]+abs(a[i]-a[i-1]),f[i-2]+abs(a[i]-a[i-2])));
        }
    }
    cout<<f[n-1]<<endl;


}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

B - Frog 2

题意：将上一题的跳跃距离改为k

思路：枚举i-k到i-1到i的代价就可以了

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=1e5+7;


void solve()
{
    int n,k;
    cin>>n>>k;
    vector<int> a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];
	vector<int> dp(n+1,1e9);
	dp[1]=0;
	//f[0]=0;
	for(int i=1;i<=n;i++){
		for(int j=i-1;j>=0&&(i-j)<=k;j--){
			dp[i]=min(dp[i],dp[j]+abs(a[i]-a[j]));
		}
	}
	cout<<dp[n]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

C - Vacation

题意：有N天，每天可以选择三件事情其中一件事情去做，获得该事情当天对应的快乐值，不能连续俩天做一样的事情，求最大的快乐

思路：对于第i天的事情，如果做A，那就是从前一天做B或者做C转移过来

dp数组开第二维分别对应ABC三件事情

f[i][A]=max(f[i-1][B]+b[i],f[i-1][C]+c[i])

对于BC同理转移

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=1e5+7;




ll f[N][5];
void solve()
{
    int n;
    cin>>n;
    vector<ll> a(n+1);
	vector<ll> b(n+1);
	vector<ll> c(n+1);
    
    for(int i=1;i<=n;i++){
    	cin>>a[i]>>b[i]>>c[i];
    }
	f[0][1]=f[0][2]=f[0][3]=0;
	for(int i=1;i<=n;i++){
		f[i][1]=max(f[i-1][2]+a[i],f[i-1][3]+a[i]);
		f[i][2]=max(f[i-1][1]+b[i],f[i-1][3]+b[i]);
		f[i][3]=max(f[i-1][1]+c[i],f[i-1][2]+c[i]);
	}
	cout<<max(f[n][1],max(f[n][2],f[n][3]))<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

D - Knapsack 1

题意：N件物品，每件有一个重量和价值，给定一个背包最大容量，求最大体积

思路：总体积较小的背包问题可以枚举重量，dp数组含义为对于重量i的最大价值是多少，注意是每件只能拿一件

对于每一种质量i: dp[i]=max(dp[i],dp[i-w[i]]+v[i])可以有

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=1e5+7;




void solve()
{
    int n,w;
    cin>>n>>w;
    vector<pair<int,ll>> q(n);
    for(int i=0;i<n;i++){
    	cin>>q[i].first>>q[i].second;
    }
    vector<ll> f(w+1,0);
    for(int i=0;i<n;i++){
    	for(int j=w;j>=q[i].first;j--){
    		f[j]=max(f[j],f[j-q[i].first]+q[i].second);
    	}
    }
    //cout<<f[3]<<endl;
    cout<<f[w]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

E - Knapsack 1

题意：同上，但是w的范围变大了

思路：改为枚举价值，最后从大到小看价值对于的质量是否超过W

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=1e5+7;



void solve()
{
    int n,w;
    cin>>n>>w;
    vector<pair<ll,int>> q(n);
	for(int i=0;i<n;i++){
		cin>>q[i].first>>q[i].second;	
	}
	vector<ll> f(N+1,1e12);
	f[0]=0;
	for(int j=0;j<n;j++){
		for(int i=N;i>=q[j].second;i--){
			f[i]=min(f[i],f[i-q[j].second]+q[j].first);
		}
	}
	
	
	for(int i=N;i>=0;i--){
		if(f[i]<=w){
			cout<<i<<endl;
			return;
		}
	}
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

F - LCS

题意：对于俩个字符串，找到最大公共字符串

思路：dp数组俩维表示a字符串到i的位置，b字符串到j的位置的时候的最大匹配

所以有if (a[i]==b[i]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1)

else dp[i][j]=max(dp[i-1][j],dp[i][j-1])

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=3e3+7;



int f[N][N];

void solve()
{
    string a,b;
    cin>>a>>b;
    f[0][0]=0;
    for(int i=0;i<a.size();i++){
    	for(int j=0;j<b.size();j++){
    		if(a[i]==b[j]){
    			f[i+1][j+1]=max(f[i+1][j+1],f[i][j]+1);
    		}
    		else{
    			f[i+1][j+1]=max(f[i+1][j],f[i][j+1]);
    		}
    	}
    }
    //cout<<f[a.size()][b.size()]<<endl;
	int i=a.size(),j=b.size();
	vector<char> ans;
	while(i!=0&&j!=0){
		if(a[i-1]==b[j-1]){
			ans.push_back(a[--i]);
			j--;
		}
		else if(f[i-1][j]<f[i][j-1]){
			j--;
		}
		else{
			i--;
		}
	}
	reverse(ans.begin(),ans.end());
	for(auto it:ans){
		cout<<it;
	}
	cout<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

G - Longest Path

题意：图上最长路径

思路：从一个点出发的时候，找他的最长儿子，然后从多个点出发都试试

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+7;

vector<int> q[N];
int dp[N];
int ans=0;
int dfs(int now){
    //cout<<1<<endl;
    if(dp[now]){
        return dp[now];
    }
    for(auto it:q[now]){
        dp[now]=max(dp[now],dfs(it)+1);
    }
    return dp[now];
}

void solve()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int x,y;
        cin>>x>>y;
        //if(x>y) swap(x,y);
        q[x].push_back(y);
        //q[y].push_back(x);
    }
    //cout<<1<<endl;
    for(int i=1;i<=n;i++){
        ans=max(ans,dfs(i));
    }
    cout<<ans;


}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

H - Grid 1

题意：询问从（1，1）到（n，m）的路径数量

思路：dp数组俩维表示到（i，j）的时候的路径数量

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

同时如果(i-1,j)是非法的就不用加，(i,j-1)同理，如果(i,j)不能走就不用修改了，记得取模QAQ

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+7;

char mp[1005][1050];
void solve()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>mp[i][j];
        }
    }

    vector<vector<ll>> f(n+1,vector<ll>(m+1,0));
    f[1][1]=1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(i==1&&j==1) continue;
            if(mp[i][j]=='#') continue;
            if(i-1>=1&&mp[i-1][j]!='#'){
                f[i][j]+=f[i-1][j]%mod;
            }
            if(j-1>=1&&mp[i][j-1]!='#'){
                f[i][j]+=f[i][j-1]%mod;
            }
            f[i][j]%=mod;
        }

    }
    cout<<f[n][m]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

I - Coins

题意：有N个硬币，丢出后每一有一个概率p，共n个p的概率朝上，求超过一半的硬币向上的概率

思路：dp数组俩维为对于前i个硬币有j个向上

dp[i][j]=dp[i-1][j-1]*p[i]+dp[i-1][j]*(1-p[i])

就是当前状态可以由i-1个硬币来，这个硬币是朝上或者朝下，

注意j-1不能越界

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=3e3+7;

double f[N][N];
void solve()
{
    int n;
    cin>>n;
    vector<double> p(n+1);
    for(int i=1;i<=n;i++){
        cin>>p[i];
    }
    f[1][1]=p[1];
    f[1][0]=(1.0-p[1]);
    for(int i=2;i<=n;i++){
        for(int j=0;j<=i;j++){
            if(j==0){
                f[i][j]=f[i-1][j]*(1.0-p[i]);
            }
            else{
                f[i][j]=f[i-1][j-1]*p[i]+f[i-1][j]*(1.0-p[i]);
            }
        }
    }
    double ans=0;
    for(int i=(n+1)/2;i<=n;i++){
        ans+=f[n][i];
    }
    cout<<setprecision(12)<<ans<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

J - Sushi 

题意：给定N个盘子，每个盘子上面有ai个寿司，每次在1到n等概率抽取一个盘子去掉一个寿司，（如果没有就不用去），求去掉全部寿司的期望

思路：ai的范围只有1~3，我们使用三维dp数组来记录每一种数量的寿司的变化，i,j,k表示使用1，2，3个寿司的盘子个数

例如使用了三个寿司的盘子，那么三个寿司的盘子数量会减少1，但是俩个盘子的数量会增加1；影响他人的要放在循环的外围，还有可以没变化的操作。

if k>0 :f[i][j][k]+=f[i][j+1][k-1]*(k/(i+j+k))

其他同理

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=300+7;
#define all (i+j+k)

double f[N][N][N];
void solve()
{
    vector<int> book(5,0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        int x;cin>>x;
        book[x]++;
    }
    for(int k=0;k<=n;k++){
        for(int j=0;j<=n;j++){
            for(int i=0;i<=n;i++){
                if(i||j||k){
                    if(i){
                        f[i][j][k]+=f[i-1][j][k]*((double)i/all);
                    }
                    if(j){
                        f[i][j][k]+=f[i+1][j-1][k]*((double)j/all);
                    }
                    if(k){
                        f[i][j][k]+=f[i][j+1][k-1]*((double)k/all);
                    }
                    f[i][j][k]+=(double)n/all;
                }
            }
        }

    }
    cout<<setprecision(12)<<f[book[1]][book[2]][book[3]]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

K - Stones

题意：一个集合有n个数字，轮流拿石头数量为集合中的数字的石头，直到有K个石头，求谁赢，没法拿的人就算输了

思路：背包问题的变形，dp数组表示数量总和为i的时候的数字，然后枚举所有质量，所有质量下去看是谁先手后手

dp[i] | =dp[i-w[j]]

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=3e3+7;



void solve()
{
    int n,k;
    cin>>n>>k;
    vector<int> v(n+1);
    for(int i=1;i<=n;i++){
    	cin>>v[i];
    }
    vector<int> dp(k+1,0);
    for(int i=1;i<=k;i++){
    	for(int j=1;j<=n;j++){
    		if(i>=v[j]){
    			dp[i]|=(!dp[i-v[j]]);
    		}
    	}
    }
    if(dp[k]){
    	cout<<"First"<<endl;
    }
    else cout<<"Second"<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

L - Deque

题意：给出一个n个数字的序列，俩人轮流从前或者后拿一个数字，结果为俩个人分别取到的数字的总和之差，先手的要让差尽可能大，后手的要让他尽可能小，求俩人都用最优策略的结果

思路：区间DP，可以枚举n个长度的时候取左边还是取右边，dp数组表示为在区间[l,r]的时候的结果，那么[l,r]区间的结果就是由[l+1,r] [l,r-1]得到的

First: dp[l][r]=max(dp[l+1][r]+a[l],dp[l][r-1]+a[r]) Second: dp[l][r]=min(dp[l+1][r]-a[l],dp[l][r-1]-a[r])

对于后手的考虑成减法就可以了

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e4;
const int N=3e3+7;

ll dp[N][N];

void solve()
{
    int n,k;
    cin>>n;
    vector<ll> a(n+1);
    for(int i=1;i<=n;i++){
    	cin>>a[i];
    }
    memset(dp,0,sizeof(dp));
    for(int len=1;len<=n;len++){
    	for(int l=1,r=len;r<=n;l++,r++){
    		if((n-len)%2==0){
    			dp[l][r]=max(dp[l+1][r]+a[l],dp[l][r-1]+a[r]);
    		}
    		else{
    			dp[l][r]=min(dp[l+1][r]-a[l],dp[l][r-1]-a[r]);
    		}
    	}
    }
    cout<<dp[1][n]<<endl; 
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

M - Candies

题意：有N个人，要分给他们K个糖果，第i个人可以收到0~ai个糖果，求有多少种分配方案

思路：dp数组表示到第i个人的时候已经分掉了j个糖果，那么dp[i][j]的状态就可以从dp[i-1][j-x]

x为0~a[j]

但是光是这样还会超时，所以对dp[i-1][j-x]要做一个前缀和处理了

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+7;

ll dp[105][N];
ll pre[105][N];
void solve()
{
    int n,k;
    cin>>n>>k;
    vector<int> a(n+1);
	for(int i=1;i<=n;i++){
    	cin>>a[i];
    }
    dp[1][0]=pre[1][0]=1;
    for(int i=1;i<=k;i++){
    	dp[1][i]=(i<=a[1]);
    	pre[1][i]=dp[1][i]+pre[1][i-1];
    }
    for(int i=2;i<=n;i++){
    	dp[i][0]=pre[i][0]=1;
    	for(int j=1;j<=k;j++){
    		if(j<=a[i]){
    			dp[i][j]=pre[i-1][j]%mod;
    		}
    		else{
    			dp[i][j]=(pre[i-1][j]-pre[i-1][j-a[i]-1]+mod)%mod;
    		}
    		pre[i][j]=(pre[i][j-1]+dp[i][j])%mod;
    	}
    }
    cout<<dp[n][k]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

N - Slimes

题意：石子合并，有N块石头，每块有一个质量，将相邻石头堆合并后代价是俩者的和，求最小的代价

思路：区间DP，从小到大枚举合并的长度，然后枚举合并时候的中间点，dp数组含义为i开始的长度为len的石头堆合并的代价

dp[i][len]=dp[i][k]+dp[k][i+len-1]+\sum w[i]

代价和可以利用前缀和计算

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+7;

ll dp[405][405];

void solve()
{
    int n;
    cin>>n;
    vector<ll> a(n+1);
    vector<ll> pre(n+1);
    memset(dp,0x3f3f3f,sizeof(dp));
	for(int i=1;i<=n;i++){
    	cin>>a[i];
    	pre[i]=pre[i-1]+a[i];
    	dp[i][1]=0;
	}
	
    for(int len=2;len<=n;len++){
    	for(int j=1;j<=n-len+1;j++){
    		for(int k=1;k<len;k++){
    			dp[j][len]=min(dp[j][len],dp[j][k]+dp[j+k][len-k]+pre[j+len-1]-pre[j-1]);
    			//cout<<dp[j][len]<<endl;
			}
    	}
    }
    cout<<dp[1][n]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

O - Matching

题意：有N个男生和N个女生，给出一个二维数组代表第i个男生和第j个女生是否匹配，求让所有人都匹配的方案数量

思路：观察到N的数量很小，像是状压DP，枚举女生所有状态，用01串表示，第i个位置是1表示有第i个女生的状态，然后和cnt个男生匹配，cnt表示该状态中拥有的女生的数量，然后枚举每一个i

看mp[cnt][i]是否匹配和这个女生是否存在在这个状态中，可以的话进行转移

这个状态可以从没有这个女生且少一个男生的状态转移来，利用了滚动数组，所以只要dp数组只要记录状态S就行了

S-（1<<i-1)就是从01串中将第i个女生（为1）去掉

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=300+7;

int mp[25][25];
int f[1<<22];
void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            cin>>mp[i][j];
        }
    }
    f[0]=1;
    for(int S=1;S<1<<n;S++){
        int cnt=__builtin_popcount(S);
        for(int i=1;i<=n;i++){
            if(mp[cnt][i]&&S>>i-1&1){
                f[S]=(f[S]+f[S-(1<<i-1)])%mod;
            }
        }
    }
    cout<<f[(1<<n)-1]<<endl;

}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

P - Independent Set

题意：给出一棵树，要给树上的点染色，可以染成白色或者黑色，黑色不能连续染，求有多少种方案

思路：经典树DP，dp数组为i的节点是染什么色的，0白1红,白色节点的子节点就可以是黑色或者白色，黑色节点下面就是白色，先遍历子节点，然后统计答案

dp[now][0]=dp[now][0]*(dp[son[i]][0]+dp[son[i][1]]) ; dp[now][1]=dp[now][1]*dp[son[i]][0]

代码：

#include <bits/stdc++.h>
//#define endl '\n'
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+7;


vector<int> q[N];
ll dp[N][2];

void dfs(int now,int fa){
    dp[now][1]=dp[now][0]=1;
    for(auto it:q[now]){
        if(it==fa) continue;
        dfs(it,now);
        dp[now][0]=(dp[now][0]*(dp[it][0]+dp[it][1])%mod)%mod;
        dp[now][1]=(dp[now][1]*dp[it][0])%mod;
    }
}

void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<n;i++){
        int x,y;
        cin>>x>>y;
        q[x].push_back(y);
        q[y].push_back(x);
    }
    dfs(1,0);
    ll ans=(dp[1][0]+dp[1][1])%mod;
    cout<<ans<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

爱吃芒果的蘑菇
关注
Android 蓝牙 A2dp 听歌卡音？audio数据到a2dp通道流程解析----A2dp流控原理（Acl Flow Control），一文搞懂蓝牙卡音问题处理
手机-手表蓝牙开发工程师的博客
04-26 5868
一、A2dp卡音问题-环境因素 先确认问题概率。（低概率则可能为干扰引起，着重关注高概率/必现卡顿问题） 确认是否是共存场景问题。（WiFi/BT共存，a2dp/hid共存等） 确认BT RF是否正常。（NV错误导致卡顿问题） WIFI OTA (WIFI天线和芯片是一起的)指标满足要求。 二、传统蓝牙HCI流控（flowcontrol） 流控制用于在主机和主机控制器之间，避免传送到主机控制器的未应答远程设备的 ACL 数据溢出主机控制器数据缓冲区。主机（蓝牙协议栈）负责管理主机控制器（蓝牙芯片.
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程
手机-手表蓝牙开发工程师的博客
04-13 2091
本文档将蓝牙A2dp播放流程进行了梳理，包括音频stream从audio侧到蓝牙侧的初始化工作、A2dp的sdp流程、A2dp 编解码协商流程、AVDTP连接流程等等
【Atcoder dp P Independent Set】 dp
我是谁 --- 卡比兽
04-30 369
Atc P 题意 给你一棵树 两个相邻的点都不能一起涂上黑色 问你有多少种涂的方案 很想一道题 没有上司的舞会 我们只要树形dp 统计白色的时候 * (子儿子白色 + 子儿子黑色) , 统计黑色的时候 * （子儿子白色） 就可以输出答案了 /* if you can't see the repay Why not just work step by step rubbish...
AtCoder Educational DP Contest
sblsf的博客
04-16 714
每天只能进行一个活动，且相邻两天不能做相同的活动。现在要挑选一些物品装入袋子里，求选择的物品的最大总价值。现在要挑选一些物品装入袋子里，求选择的物品的最大总价值。很大，直接套用01背包计算，时间和空间肯定一定炸。给定两个字符串，输出它们的任意一个最长公共子序列。经典01背包问题，按照01背包的解法做即可。只能从另外两个状态中的最大值转移过来。由于相邻两天不能做相同的活动，所以。的最小重量，这样就不会炸了。很小，我们可以转换思路，设。，就可以递归输出方案。号石头时的最小代价。号石头时的最小代价。
B - Backfront（atcoder） (dp应用+找规律)
代码行
07-24 390
B - Backfront Time limit : 2sec / Memory limit : 1024MB Score : 500 points Problem Statement You are given a sequence (P1,P2,…,PN) which is a permutation of the integers from 1 through N. You woul...
Atcoder dp_i
最新发布
weixin_51108620的博客
07-11 539
dp求概率
AtCoder：Infinite Sequence（dp）
junior19的博客
05-13 423
F - Infinite Sequence Time limit : 2sec / Memory limit : 256MB Score : 1000 points Problem Statement How many infinite sequences a1,a2,… consisting of {1,…,n} satisfy the following c
dp主机_miniDP转DP和type-C转DP连接线上机简单测评
weixin_39890629的博客
11-10 5657
今天给大家测试的两款dp转接线：一是miniDP转DP，一款是type-C口转DP。这是miniDP转DP线，包装盒很好看，线的两个接头质量也是非常好，让人很放心。两端都有黑色网保护，连接头也有保护套，细节做得很好。再就是Type c转DP，盒子一样的，都很漂亮。Type c转DP线采用尼龙编织，看官方宣传说端子采用铜壳镀金，虽然看不太明显，但是接口做工真的不错，很精细。保护已然很到位，好评。先说...
蓝牙音频A2DP（一）-- A2DP音频设备加载
chinaycheng的专栏
02-28 4656
蓝牙A2DP设备加载过程
蓝牙音频A2DP（三） -- UIPC
chinaycheng的专栏
02-28 6659
Bluedroid UIPC转发命令机制
atcoder Picking Goods(DP)
qq_43555854的博客
08-17 174
题目链接 题意： 有个n*m的矩阵，里面放了k个数，现在让你从左下角走到右上角，只能向上走和向右走，路过一个数就可以把那个数加进答案，也可以不加，限制是每一行最多只能选3个数，现在问你答案最大值是多少。 r,c<=3000 k<=1e5 放进去的数<=1e9 思路： dp[i][j][k]表示在i行j列该行已经取了k个数的最大值，dp即可。 记得开ll。 #include <bits/stdc++.h> #define ll long long using namespace
atcoder dp Deque
the best 的博客
11-16 235
题意： 给出一个数组a，两人轮流选数，要求只能从数组的头尾选数，并且得分加上选的这个数，数被选后会在数组中删掉，先手得分为X，后手得分为Y，先手希望X-Y最大，后手希望X-Y最小，两人都采取最优策略，问最后X-Y为多少。 题解： 可以转变为先手希望X-Y最大，后手希望Y-X最大，那么设dp[i][j]表示为 区间i~j的X-Y的最大值或Y-X的最大值。那么状态转移就有了 dp[i][j]=max(a[i]-dp[i+1][j],a[j]-dp[i][j-1]); 为什么要减？因为X-Y和Y-X差了一个符号
【刷题记录】[AtCoder Educational DP Contest] 经典dp类型及方法题解合集
03-31 1986
温故而知新，不为师至少不是孙子
【AtCoder】【DP】【思维】 Salvage Robots(AG004)
G20202502的博客
09-19 377
题意： 有一个n*m的矩阵，每一个格子中只会含有以下的字符：’.'表示位置为空，'o’表示这个位置有一个机器人，'E’表示这个位置为出口。保证出口只会出现一次。 现在你可以命令让所有的机器人同时向上或下或左或右移动一步。如果这个机器人掉出了矩阵，那么就无法营救这个机器人了，并且这个机器人会消失；如果这个机器人到达了Exit，那么它就被成功营救了，也会立即消失。 现在要你求经过上述操作后能够营救的机...
AtCoder - ABC 267 - F（dp）
m0_64172681的博客
09-06 179
有 n 个数，求取 ⌊⌋ 个两两不相邻的数的最大和。
Atcoder E - Payment(DP)
一身清贫怎敢入繁华
02-23 541
题意： 在一个国家有有10100+110^{100}+110100+1种货币，分别是价值为1,101,102,103.......101001,10^1,10^2,10^3.......10^{100}1,101,102,103.......10100的货币，现在你在超市买东西，你需要支付NNN元，问你和货员在这个过程中用到的总票数最小是多少张。 思路： 从低位到高位，每一位只有两种选择， 1、支...
atcoder dp专题(updating)
qq_43412251的博客
02-02 814
atcoder dp专题 E 是一个背包问题的变式，因为其背包容量达到了1e9，所以常规的一维数组无法存下，而每个物品的价值很小，所以我们将一维数组的下标定义为物品的价值。从寻找一定空间的最大价值，变式为一定价值所需的最小空间。 for(int i=1;i<=n;i++) for(int j=MAXN-1;j>=c[i];j--) { dp[j]=min(dp[j],dp[j-c[i]]+w[i]); if(dp[j]<=m)
【Atcoder DP_L Deque】Dp
我是谁 --- 卡比兽
04-29 708
Atc dp_l 题意 给你一个序列 一个人先拿 另一个人后拿 只能从序列的开头或者结尾拿一个元素 先拿的分数是 X 后拿的人分数是 Y 他们都想要自己的分数差最大 也就是第一个人是 X - Y最大 第二个人是 Y - X最多 我们发现对这类dp 只有dp[l][r] 代表区间 l 到 区间 r 的最大 X - Y 只有当L = R的时候 才能确定取的是arr[l],arr[R] 如果不等于 就从...
【AtCoder】【DP】Colorful Slimes(AG004)
G20202502的博客
09-19 491
题意： 有N种颜色的史莱姆，每种颜色有无线多个史莱姆。每次可以花Ai的代价抓一只没有的史莱姆，或者是花费x的代价让已经有的所有的史莱姆的颜色+1（颜色为N的变为1）。 数据范围： 1&amp;lt;=N&amp;lt;=10^5 1&amp;lt;=x&amp;lt;=10^9 思路： 因为可以让其他的史莱姆通过变换颜色来得到当前我们想要的史莱姆，所以说一种颜色的史莱姆显然是要被多次捕捉的。然后，我们可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱吃芒果的蘑菇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值