CSP-201809-4-再卖菜

问题描述

　　在一条街上有n个卖菜的商店，按1至n的顺序排成一排，这些商店都卖一种蔬菜。
　　第一天，每个商店都自己定了一个正整数的价格。店主们希望自己的菜价和其他商店的一致，第二天，每一家商店都会根据他自己和相邻商店的价格调整自己的价格。具体的，每家商店都会将第二天的菜价设置为自己和相邻商店第一天菜价的平均值（用去尾法取整）。
　　注意，编号为1的商店只有一个相邻的商店2，编号为n的商店只有一个相邻的商店n-1，其他编号为i的商店有两个相邻的商店i-1和i+1。
　　给定第二天各个商店的菜价，可能存在不同的符合要求的第一天的菜价，请找到符合要求的第一天菜价中字典序最小的一种。
　　字典序大小的定义：对于两个不同的价格序列(a₁, a₂, ..., a_n)和(b₁, b₂, b₃, ..., b_n)，若存在i (i>=1), 使得a_i<b_i，且对于所有j<i，a_j=b_j，则认为第一个序列的字典序小于第二个序列。

输入格式

　　输入的第一行包含一个整数n，表示商店的数量。
　　第二行包含n个正整数，依次表示每个商店第二天的菜价。

输出格式

　　输出一行，包含n个正整数，依次表示每个商店第一天的菜价。

样例输入

8
2 2 1 3 4 9 10 13

样例输出

2 2 2 1 6 5 16 10

数据规模和约定

　　对于30%的评测用例，2<=n<=5，第二天每个商店的菜价为不超过10的正整数；
　　对于60%的评测用例，2<=n<=20，第二天每个商店的菜价为不超过100的正整数；
　　对于所有评测用例，2<=n<=300，第二天每个商店的菜价为不超过100的正整数。
　　请注意，以上都是给的第二天菜价的范围，第一天菜价可能会超过此范围。

 

第一眼看过去就是dp，但是复杂度有点爆炸，然后以为dp不可解。

就试了试dp没想到竟然A了，前提是数据不是很极限否则A不了的。学正解的话还是去学差分约束吧，范围再大点也能解，dp只能应付小范围数据。（差分约束解在下面）

令f[i][j][k]表示 第一天：i位置的菜价为j，i+1位置的菜价为k

此时是否可以满足第二天：[i+1,n]位置的菜价约束，是的话f[i][j][k]=1否则f[i][j][k]=0

nt[i][j][k]就是记录下满足条件的最小的一个第i+2天的菜价l是多少，方便找路径输出。

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

bool f[310][310+5][310+5];
int nt[310][310+5][310+5];
int a[310],n,MAX=0;
int main(){
    cin>>n;
    for(int i=1;i<=n;++i)cin>>a[i],MAX=max(MAX,a[i]*3+5);
    for(int i=1;i<=MAX;++i){
        for(int j=1;j<=MAX;++j){
            if((i+j)/2==a[n]){
                f[n-1][i][j]=1;
                nt[n-1][i][j]=0;
            }
        }
    }
    for(int i=n-1;i>=2;--i){
        for(int k=MAX;k>=1;--k){
            for(int l=MAX;l>=1;--l){
                if(f[i][k][l]){
                    for(int j=1;j<=MAX;++j){
                        if((j+k+l)/3==a[i]){
                            f[i-1][j][k]=1;
                            nt[i-1][j][k]=l;
                        }
                    }
                }
            }
        }
    }
    bool con=1;
    for(int i=1;con&&i<=MAX;++i){
        for(int j=1;con&&j<=MAX;++j){
            if(f[1][i][j] && (i+j)/2==a[1]){
                int l=i,r=j;
                cout<<l;
                for(int k=2;k<=n;++k){
                    cout<<' '<<r;
                    int tmp=nt[k-1][l][r];
                    l=r;
                    r=tmp;
                }
                con=0;
            }
        }
    }cout<<endl;
    return 0;
}

下面是差分约束的代码：

利用前缀和S(n)-S(n-2)>=K 来代替a[i-1]+a[i]+a[i+1]>=K然后建边，注意每个S(i)-S(0)>=1这个隐含的条件。

#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define inf 0x3f3f3f3f
#define pii pair<int,int>
#define mp make_pair

const int maxn=310;
vector<pii>g[maxn];
int n;
int a[maxn];
bool inq[maxn];
int d[maxn];
bool spfa(){
    queue<int>q;
    memset(d,-inf,sizeof(d));
    d[0]=0;
    inq[0]=1;
    q.push(0);
    while(!q.empty()){
        int u=q.front();q.pop();inq[u]=0;
        for(auto e:g[u]){
            int v=e.first,w=e.second;
            if(d[v]<d[u]+w){
              d[v]=d[u]+w;
              if(!inq[v]){
                inq[v]=1;
                q.push(v);
              }
            }
        }
    }return 1;
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;++i)cin>>a[i];
    for(int i=1;i<=n;++i){
        if(i==1){
            g[0].push_back(mp(2,2*a[1]));
            g[2].push_back(mp(0,-2*a[1]-1));
        }else if(i==n){
            g[n-2].push_back(mp(n,2*a[n]));
            g[n].push_back(mp(n-2,-2*a[n]-1));
        }else{
            g[i-2].push_back(mp(i+1,3*a[i]));
            g[i+1].push_back(mp(i-2,-3*a[i]-2));
        }
    }
    for(int i=0;i<=n-1;++i) g[i].push_back(mp(i+1,1));
    spfa();
    for(int i=1;i<=n;++i)cout<<d[i]-d[i-1]<<' ';cout<<'
';
    return 0;
}