疯狂刷dp中

最新推荐文章于 2020-08-12 20:01:22 发布
最新推荐文章于 2020-08-12 20:01:22 发布
阅读量132 收藏
点赞数
分类专栏： acm暑训 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qcccc_/article/details/107849564
版权
acm暑训 同时被 2 个专栏收录
47 篇文章 1 订阅
订阅专栏
dp
19 篇文章 0 订阅
订阅专栏

数字游戏
这是一个很好的区间dp题，个人感觉，容易想到，但是不容易写出来，边界处理很强，预处理出，前缀和，最小值需要初始化，破坏环成为两倍的大小的数组，细节很多。

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e5 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const int p=1e7+233;
const  double pi=3.141592653589;
int dpma[105][105][12],dpmi[105][105][12];
int a[105];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        a[i+n]=a[i];//破坏环
    }
    ms(dpmi,inf);
    for(int i=2;i<=2*n;i++)a[i]+=a[i-1];//前缀和
    for(int i=1;i<=2*n;i++)
    {
        for(int j=i;j<=2*n;j++)
        {
            dpma[i][j][1]=dpmi[i][j][1]=((a[j]-a[i-1])%10+10)%10;//预处理
        }
    }
    for(int i=2;i<=m;i++)//枚举断点个数
    {
        for(int l=1;l<=2*n;l++)//左端点
        {
            for(int r=l+i-1;r<=2*n;r++)//右端点
            {
                for(int k=l+i-2;k<r;k++)//枚举断点位置
                {
                    dpma[l][r][i]=max(dpma[l][k][i-1]*(((a[r]-a[k])%10+10)%10),dpma[l][r][i]);
                    dpmi[l][r][i]=min(dpmi[l][k][i-1]*(((a[r]-a[k])%10+10)%10),dpmi[l][r][i]);
                }
            }
        }
    }
    int ma=0,mi=inf;
    for(int i=1;i<=n;i++)
    {
        ma=max(ma,dpma[i][i+n-1][m]);
        mi=min(mi,dpmi[i][i+n-1][m]);
    }
    printf("%d\n%d\n",mi,ma);
    return 0;
}

P1052 过河

通过这个题我学到许多，这种路径压缩是真的强，放在我是想不到，我想的是离散，然而离散的话就不好控制特么之间的距离，路径压缩我感觉是离散的一种拓展，和离散十分的相似（个人感觉）

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e5 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int a[105],flage[maxn],dp[maxn];//看好空间大小啊
int main()
{
    int L;
    int S,T,M;
    scanf("%d%d%d%d",&L,&S,&T,&M);
    if(S==T)//一定要特判啊
    {
        int x,cnt=0;
        for(int i=1;i<=M;i++)
        {
            scanf("%d",&x);
            cnt+=(x%S==0);
        }
        printf("%d\n",cnt);
        return 0;
    }
    for(int i=1;i<=M;i++)
    {
        scanf("%d",&a[i]);
    }
    sort(a+1,a+1+M);
    a[M+1]=L;
    ms(dp,inf);
    dp[0]=0;
    a[0]=0;
    int p=0;
    for(int i=1;i<=M;i++)
    {
        int far=min(90,a[i]-a[i-1]);//如果想看证明过程的话请到洛谷去看，可以通过上面的链接进入，也可以自己去搜索，进去后第一个题解有详细证明过程。其实只要开到(T+1)*T-T-(T+1)也就是71就足够了
        p+=far;
        flage[p]=1;
    }
    p+=min(90,L-a[M]);
    for(int i=0;i<=p+T-1;i++)
    {
        for(int j=S;j<=T;j++)
        {
            if(i-j>=0)
            dp[i]=min(dp[i],dp[i-j]+flage[i]);
        }
    }
    int ans=inf;
    for(int i=p;i<=p+T-1;i++)//因为你可能是条过了桥，可能从L-1跳到L-1+(S到T内的一个数)，也可能是l-2+(S到K内的一个数),所以答案在p到p+T-1内
    {
        ans=min(ans,dp[i]);
    }
    printf("%d\n",ans);
    return 0;
}

P1095 守望者的逃离

本题主要是要想到把位移与休息和跑步分开分别求一次dp，这样就十分简单了

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =3e5 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int dp[maxn];
int main()
{
    int m,s,t;
    scanf("%d%d%d",&m,&s,&t);
    for(int i=1;i<=t;i++)
    {
        if(m>=10)
            dp[i]=dp[i-1]+60,m-=10;
        else
            m+=4,dp[i]=dp[i-1];
    }
    for(int i=1;i<=t;i++)
    {
        dp[i]=max(dp[i],dp[i-1]+17);
    }
    if(dp[t]<s)
    {
        printf("No\n%d\n",dp[t]);
    }
    else
    {
        printf("Yes\n");
        for(int i=1;i<=t;i++)
        {
            if(dp[i]>=s)
            {
                printf("%d\n",i);
                return 0;
            }
        }
    }
    return 0;
}

P1108 低价购买

没想到这么容易的一个题目我看题解都看了半天，我也是醉了，还是不喜欢独立思考啊，这毛病要改啊，

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =3e5 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int dp[maxn],n,a[maxn],f[maxn];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    int ma=1;
    for(int i=1;i<=n;i++)
    {
        dp[i]=1;
        for(int j=1;j<i;j++)
        {
            if(a[i]<a[j])
            {
                dp[i]=max(dp[i],dp[j]+1);
                ma=max(ma,dp[i]);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(dp[i]==1)f[i]=1;
        for(int j=1;j<i;j++)
        {
            if(dp[i]==dp[j]+1&&a[i]<a[j])//如果dp[j]+1==dp[i]并且a[i]<a[j],那么a[j]一定可以链接上a[i]成为长度位dp[i],所以加起来
            {
                f[i]+=f[j];
            }
            else if(dp[i]==dp[j]&&a[i]==a[j])//如果两个都相等的话舍弃一个对结果没有影响
                f[j]=0;
        }
    }
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        if(dp[i]==ma)sum+=f[i];
    }
    printf("%d %d\n",ma,sum);
    return 0;
}

P1099 树网的核
本题是树形dp之类的题目很容易，但是又不好想，首先树的直径肯定是要求的，然后在树的直径上尺取法找最大值中的最小值，但是要考虑的是，如果s大于树的直径的话,那么这样求出来的可能就是0了，但是如果他还有分支的话，那么绝对不可能是0,所有还要求其他的点到树的直径的距离和答案取个最大值就可了。

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e3 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int n,s,pa[maxn],max_len=0,dis[maxn],k=0,vis[maxn];
vector<pair<int,int> >ve[maxn];
void dfs(int u,int f)
{
   pa[u]=f;
   if(dis[k]<dis[u])k=u;
   for(int i=0;i<ve[u].size();i++)
   {
       int to=ve[u][i].first;
       if(to==f||vis[to])continue;
       dis[to]=dis[u]+ve[u][i].second;
       dfs(to,u);
   }
}
int main()
{
    scanf("%d%d",&n,&s);
    for(int i=1;i<n;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        ve[u].push_back({v,w});
        ve[v].push_back({u,w});
    }
    dis[1]=0;
    dfs(1,-1);
    int st=k;
    dis[k]=0;
    dfs(k,-1);
    int ed=k;
    int ans=inf;
    for(int i=ed,j=ed;i+1&&j+1;i=pa[i])
    {
        while(dis[j]-dis[i]>s)j=pa[j];
        ans=min(ans,max(dis[i],dis[ed]-dis[j]));
    }
    for(int i=ed;i+1;i=pa[i])vis[i]=1;
    for(int i=ed;i+1;i=pa[i])
    {
        k=i,dis[k]=0;
        dfs(i,pa[i]);
    }
    for(int i=1;i<=n;i++)
    {
        ans=max(ans,dis[i]);
    }
    printf("%d\n",ans);
    return 0;
}

P3399 丝绸之路
,本题我采用的是单调队列优化dp，但是我看题解没有写的这么麻烦，但是做出来了就是王道，其实三重循环加o2也可以过，不加o2直接超时，加了单调队列100ms，还是可以接受的，我看其他人的就50ms左右得去学习一下。
,不加单调队列的暴力写法

  for(int i=1;i<=n;i++)
    {
        for(int j=i;j<=m;j++)
        {
            for(int k=i-1;k<=j-1;k++)
            dp[i][j]=min(dp[i-1][k]+a[i]*b[j],dp[i][j]);
        }
    }

，加了单调队列的写法

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e3 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int a[maxn],dp[1005][1005],b[maxn];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&b[i]);
    }
    ms(dp,inf);
    for(int j=0;j<=m;j++)
        dp[0][j]=0;
    deque<int>q;
    for(int i=1;i<=n;i++)
    {
        q.push_back(i-1);
        for(int j=i;j<=m;j++)
        {
            dp[i][j]=min(dp[i-1][q.front()]+a[i]*b[j],dp[i][j]);
            while(dp[i-1][q.front()]>=dp[i-1][j]&&!q.empty())
                q.pop_back();
            q.push_back(j);
            //bug;
        }
        while(!q.empty())q.pop_back();
    }
    int ans=inf;
    for(int j=n;j<=m;j++)
        ans=min(ans,dp[n][j]);
    printf("%d\n",ans);
    return 0;
}

.哇哦，我取经回来了原来是我定义的dp[i][j]是到达第i个城市用了j天，大佬的是第i天到达第j个城市代码直接给上

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e3 + 5;
const int maxm = 1.5e5+50;
const double eps = 1e-7;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int a[maxn],b[maxn],dp[1005][1004];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int j=1;j<=m;j++)
    {
        scanf("%d",&b[j]);
    }
    ms(dp,inf);
    dp[0][0]=0;
    for(int i=1;i<=m;i++)
    {
        for(int j=0;j<=min(n,i);j++)
        {
            if(j==i)dp[i][j]=dp[i-1][j-1]+a[j]*b[i];
            else
            dp[i][j]=min(dp[i-1][j],dp[i-1][j-1]+a[j]*b[i]);//dp[i-1][j]代表第i天休息但已经到达j，            与第i-1天走到j花费的最小值
        }
    }
    int ans=inf;
    for(int i=n;i<=m;i++)
        ans=min(ans,dp[i][n]);
    printf("%d\n",ans);
    return 0;
}

POJ - 1651
，最近唯一自己写出来的dp题目很容易，而且还是自己写过一个类似的题目才写出来的，，要加油了啊，不要拖后腿啊，由于是自己写出来的就不写题解了，直接上代码吧

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e6+10;
const int maxm = 1.5e5+50;
const double eps = 1e-18;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int a[1005],dp[1005][1005];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    ms(dp,inf);
    for(int i=1;i<=n;i++)
    {
        dp[i][i+2]=a[i]*a[i+1]*a[i+2];
        dp[i][i]=dp[i][i+1]=0;
    }
    for(int len=3;len<=n;len++)
    {
        for(int l=1;l+len-1<=n;l++)
        {
            int r=len+l-1;
            for(int k=l+1;k<r;k++)
            {
                dp[l][r]=min(dp[l][r],dp[l][k]+dp[k][r]+a[l]*a[k]*a[r]);
            }
        }
    }
    printf("%d\n",dp[1][n]);
    return 0;
}

HDU - 2476
,还是区间dp问题，不过这一个思路倒是没错，但是写的顺序撮了第一个dp方程一定要写出来很经典，第二个就要想一想了

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =1e6+10;
const int maxm = 1.5e5+50;
const double eps = 1e-18;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
char a[105],b[105];
int dp[105][105],f[105];
int main()
{
    while(~scanf("%s%s",a+1,b+1))
    {
        int n=strlen(a+1);
        ms(dp,0);
        for(int i=1; i<=n; i++)dp[i][i]=1;
        for(int len=2; len<=n; len++)
        {
            for(int l=1; l+len-1<=n; l++)
            {
                int r=l+len-1;
                if(b[l]==b[r])
                    dp[l][r]=min(dp[l][r-1],dp[l+1][r]);
                else
                    dp[l][r]=min(dp[l][r-1]+1,dp[l+1][r]+1);
                for(int k=l; k<=r; k++)
                {
                    dp[l][r]=min(dp[l][k]+dp[k+1][r],dp[l][r]);
                }
            }
        }
        for(int i=1;i<=n;i++)
            f[i]=dp[1][i];
        for(int i=1;i<=n;i++)
        {
            if(a[i]==b[i])
            {
               f[i]=f[i-1];
            }
            else
            {
                for(int k=1;k<i;k++)
                {
                    f[i]=min(f[i],f[k]+dp[k+1][i]);
                }
            }
        }
        printf("%d\n",f[n]);
    }
    return 0;
}

You Are the One HDU - 4283
本题还是区间dp的题我还是看了好久的题解，害写出来以后发现就那样，枚举区间长度，枚举左端点，找到有端点，枚举断点没了。

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<deque>
#include<map>
#include<stdlib.h>
#include<set>
#include<iomanip>
#include<stack>
#define ll long long
#define ms(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x & -x
#define fi first
#define ull unsigned long long
#define se second
#define endl "\n"
#define bug cout<<"----acac----"<<endl
#define IOS ios::sync_with_stdio(false), cin.tie(0),cout.tie(0)
using namespace std;
const int maxn =2e2+10;
const int maxm = 1.5e5+50;
const double eps = 1e-18;
const double inf = 0x3f3f3f3f;
const double  lnf  = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
const  double pi=3.141592653589;
int a[maxn],dp[maxn][maxn],sum[maxn];
int main()
{
    int T;
    scanf("%d",&T);
    int cas=1;
    while(T--)
    {
        ms(dp,inf);
        ms(sum,0);
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            dp[i][i]=0;
            sum[i]=sum[i-1]+a[i];
        }
        for(int len=2;len<=n;len++)
        {
            for(int l=1;l+len-1<=n;l++)
            {
                int r=len+l-1;
                dp[l][r]=min(dp[l][r],dp[l+1][r]+(r-l)*a[l]);
                for(int k=l;k<=r;k++)
                {
                    dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]+(k-l+1)*(sum[r]-sum[k]));//这里因为要把dp[k+1][r]和之前的那个区间合并，所以之前的那个区间先是全部上完了，然后这个区间再上，所以要加上，上一个区间的区间长度乘以他们的屌丝值，
 //dp[i][j](只考虑i到j这个区间内值不考虑其他的，也就是说现在只有i到j这么多人在参见这个活动)代表i到j内屌丝值乘以上场顺序的最小值
                }
            }
        }
        printf("Case #%d: %d\n",cas++,dp[1][n]);
    }
    return 0;
}
qcccc_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
疯狂 dp（一） 线性 dp
Just Coding！
04-18 3508
动态规划是为了求解一种包含大量重叠子问题的最优化问题的方法。基本思想是，将原问题分解为若干相似的子问题，在求解的过程中通过子问题的解求出原问题的解。听起来和分治法很相似，但是，分治法只是不断地将问题分解成小问题求解，而动规之所以优秀是它会进行类似于记忆化搜索的过程，在求解的过程中把每一个子问题的解保存下来（不管后面会不会用到），然后在求解更大的问题时，从这些子问题的解里面寻求当前问题的最优解。所以
疯狂DP（动态规划）
weixin_47532216的博客
11-18 377
  第一个小目标：50道动态规划题目。
刷dp题神器，各类dp题目总表（挖一个坑以后慢慢做）
蒟蒻的博客
06-05 2801
题目列表(标*号的为难度较大的题目) 背包 bzoj2287 poj3093 Bzoj2748 *Bzoj2794 *bzoj1190树形 Bzoj4472 Bzoj1864 *Bzoj4033 *Bzoj3167 *Bzoj4446 状压 Bzoj1087 Bzoj3195 Bzoj4145 *Bzoj1226 *Bzoj2064 *Bzoj4197 数位
【疯狂DP】CCFOJ1185、1186_数的划分一、二 题解——从DFS到DP
IDDFS
07-06 411
题目 1185 描述 把正整数N分解成M个正整数的和，即使M个数相同但顺序不同也认为是不同的方案，要求总方案数。如3=1+2跟3=2+1是两个不同的方案。 输入 第一行包含两个整数N和M。 输出 输出一个数表示方案数。 样例 输入 3 2 输出 2 数据范围 1<=M<=N<=50 1
做DP题的一些总结（自用，勿看，如果你没做过这些题，会影响做题质量）
Zolrk的博客
08-20 1673
1.统计单词个数 https://www.luogu.org/problemnew/show/P1026 DP的过程实际上就是拼凑最优解的过程，因此，可以先想想最优方案是如何构成的，然后对最优方案进行优美地分解，使得其可以转移，（分解可以是一行一列一段一层（树上）！），比如这题我一开始状态设对了。。。但是因为太弱，没能想出来一段一段转移，而是考虑一个一个字符转移。看来做不出时就要拓展思路，拓展...
leetcode+ Dp题目，字符串匹配
小堃哥的专栏
06-21 594
点击打开链接class Solution { public: bool isMatch(string s, string p) { int slen = s.length(); int plen = p.length(); int num = 0; for(int i=0; i&lt;plen; i++){ ...
DP83640中文（寄存器说明）
07-14
DP83640 寄存器说明中文指南 DP83640 是一款高性能的以太网PHY 芯片，具有丰富的寄存器配置，用于控制和监控以太网连接。下面是 DP83640 寄存器的中文说明： 寄存器说明目录 DP83640 寄存器说明目录共分为五个...
PHY DP83848 中文文档
09-17
TI的DP83848 中文文档 非常好用的PHY。支持10Mb/s 和 100Mb/s
DP.rar_DP
09-20
标题中的"DP.rar_dp"可能是指动态规划（Dynamic Programming，简称DP）的压缩包文件，其中包含了关于这个算法的各种资源。动态规划是一种在计算机科学和数学中广泛使用的优化技术，主要用于解决多阶段决策过程的问题...
Milking Time POJ - 3616
qcccc_的博客
07-28 1482
Bessie is such a hard-working cow. In fact, she is so focused on maximizing her productivity that she decides to schedule her next N (1 ≤ N ≤ 1,000,000) hours (conveniently labeled 0..N-1) so that she produces as much milk as possible. Farmer John has a l
F - Ants CodeForces - 318D
qcccc_的博客
08-07 871
题目戳我 早训的cf题目，当时一直没写出来但是知道怎么写一直调不出来就很烦，因为可能是负数，所以我们把(0,0)变成(1000,1000)结合题目给定的蚂蚁数量就再也不可能有负数出现了，先bfs预处理出所有蚂蚁的位置就很舒服了，可是细节不到位，写撮了。 #include<iostream> #include<stdio.h> #include<math.h> #include<string.h> #include<string> #includ
2020牛客暑期多校训练营（第二场）C Cover the Tree
qcccc_的博客
07-15 839
这题比赛的时候想了半天，码了出来后发现是错的，当场无语， 后来hl学长告诉先跑一遍dfs序然后记录一下度为1的点出现的顺序，再输出。具体代码讲 #include<iostream> #include<stdio.h> #include<math.h> #include<string.h> #include<string> #include<vector> #include<queue> #include<algor.
P2770 航空路线问题
qcccc_的博客
08-05 649
题目戳我 本题有一个套路，就是来回一个圈从a到b在到c可以看成从a到b和c，因为这题是网络流所以考虑建图,像这种网络流建图一个点只能通过一次的图，一般情况下都是要拆点的.然后拆点后就要考虑边的容量和cost的分布了，边的容量那么终点和起点都是2其他都是1，cost都为1，因为都是一个点,最后答案再减去2以为起点和终点都经过了两次。如果最后求得的流量是2,说明有两条路径,如果是1的话可能存在1直接到n这种情况，特判一下就好了，其余的都无法到达，具体看代码吧。 #include<iostream>
牛客算法周周练16 Rinne Loves Dynamic Graph
qcccc_的博客
07-22 346
我太菜了，这种题目对于我来说还是太难了， 题目链接 这个题目的规律应该很容易找到，循环是3次一循环，然后是否你这样写了代码我wa了6发才发现这样写是不对的，为什么呢？因为f(1)肯定是最大，其他的两个都是在1左右的数，那么就可能发生一些本应该可以用f(2)的地方就用了f(1)导致答案偏大，那么到底该怎么建图呢？那么我们可以把一条单向边分成三种情况，那么无向边就是6种情况了，考虑单向边，我们可以建立一条第一层（u，v+n,w1）的边，（第二层u+n,v+2n,w2），第三层（u+2n,v,w3）（循环回到第.
H - GCD - Extreme (II)（欧拉函数）
qcccc_的博客
07-14 343
数论（欧拉函数的应用） 写题解之前先说一下：这种解法不是看别人的题解写出来的是真的强（也可能是我太菜了吧） 题目链接 然后这是我参考的大佬的题解的链接 大佬的题解 题意：就是求题目中那个程序，只不过要化简一下，不然绝对会超时 题解：化简程序后可以得到其中有一部分是f(n)=gcd(1,n)+gcd(2,n)+…+gcd(n-1,n);还有几部分是f(n-1)=gcd(1,n-1)+gcd(2,n-2)+…+gcd(n-2,n-1);以此类推：可以得到f(n-2),f(n-3)…f(2); 为什么没有f(1)
P4017 最大食物链计数(简单的树形dp)
qcccc_的博客
08-12 274
P4017 最大食物链计数 由于数据不存在环，所以一定能找到食物链的起点，那么就可以由食物链的起点记忆化搜索直到终点然后返回1，说明有一条食物链，然后就没了，具体看代码理解吧 #include<iostream> #include<stdio.h> #include<math.h> #include<string.h> #include<string> #include<vector> #include<queue> #
牛客算法周周练15 树上求和(dfs序线段树)
qcccc_的博客
07-14 267
题目链接 题目意思明了，看起来像线段树，但是又不像线段树，线段树的单一题目一般都直接给出一个数列，然后要你求区间之间的一些值，维护一些值，但是这个题目又不是给你一个数列，而是一颗树，那么就要想办法改成线段树，这样dfs序就来了，因为dfs序中一个点的进来的位置与出去的位置之间恰好是他的子树所在区间，和题目要求的东西刚刚好。(至于为什么是这样百度一下dfs序就知道了)。 int in[maxn],out[maxn],cnt,vis[maxn]，fir[maxn];//in进去的位置，out出来的位置，vis第
dp83848中文手册 csdn
最新发布
07-25
手册中包含了DP83848的硬件和软件设计指南，以及相关接口、寄存器和时序的详细说明。通过阅读手册，开发人员可以了解DP83848的功能和特性，以及如何正确配置和操作它。 手册还提供了DP83848的性能参数和电气特性的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值