第十三次考试

Posted 2020-12-29 lajioj

水题争霸赛，然而我最菜(qwq)

T1 导航

【题目描述】：
约翰在他的新车上装了两个导航系统((GPS))，但这两个(GPS)选择的导航线路常常不同，约翰很是恼火。
约翰所在的小镇地图由(N)个路口和(M)条单向道路构成，两个路口间可能有多条道路相连。约翰的家在(1)号路口，他的农场在(N)号路口。约翰从家出发，可以经过一系列的道路，最终到达农场。
两个(GPS)用的都是上述地图，但是，它们计算时间的算法不同。比如，经过第(i)条道路，(1)号(GPS)计算出的时间是(P_i)分钟,而(2)号(GPS)算出的时间是(Q_i)分钟。
约翰想要驾车从家到农场，但是，如果一个(GPS)认为约翰当前行走的这条路不在它算出的最短路径中，该(GPS)就会大声抱怨约翰走错了路。更倒霉的是，有可能两个(GPS)会同时抱怨约翰当前走的路不是它们推荐的。
请帮助约翰计算，从家到农场过程中，选择怎样的路径才能使得(GPS)抱怨的次数最少，请算出这个最少的抱怨次数。如果一条路上两个(GPS)都在抱怨，算两次((+2))抱怨。

【输入格式】：
第(1)行： 两个空格间隔的整数:(N)和(M)
接下来(M)行，每行描述一条道路。第(i)行描述第(i)条道路，由四个空格间隔的整数构成，(A_i),(B_i),(P_i),(Q_i),分别表示该条道路的起点、终点、(1)号(GPS)计算的耗时、(2)号(GPS)计算的耗时。

【输出格式】：
第(1)行： (1)个整数， 表示所求答案。

【样例输入】：

5 7
3 4 7 1
1 3 2 20
1 4 17 18
4 5 25 3
1 2 10 1
3 5 4 14
2 4 6 5

【样例输出】：

1

【数据范围】：
对于(30\%) 的数据，(1<= N <=20),(1<= M <=20)
对于(100\%)的数据，(1<= N <=10000) ,(1 <= M <= 50000) ,(0<=Pi,Qi<=100000)

思路：

因为每到一个新的节点后，原来所计算出来的最短路可能会被更新，所以应该比较自然地想到先反向建边，求出(n)到所有节点的最短路径，所以先跑两次(spfa)，分别用(GPS1)和(GPS2)作为边权，得到两个(dis)数组。
对于两次(spfa)，记录两个(pre)数组记录路径，那么对于这两条路径，进行如下处理：

• 如果存在(u,v)，它们既在(pre1)中，又在(pre2)中，显然经过这条路径时，两个(GPS)都不会抗议，就连一条权为(0)的边
• 如果存在(u,v)，它们仅在(pre1)中，或仅又在(pre2)，显然经过这条路径时，其中一个(GPS)会抗议，就连一条权为(1)的边，
• 对于其他路径，显然两个(GPS)都会抗议，就连一条权为(2)的边

然后再跑一边(spfa)，最短路的值即为答案。
这么水我居然只有80

#include<cstdio>
#include<cstring>
#include<queue>
#define inf 0x3f3f3f3f
using namespace std;

int n,m;

const int MAXM = 50005;
const int MAXN = 10005;

struct edge{
    int u,v,w1,w2,nxt,w;
}e[MAXM];int head[MAXN];int cnt=0;int dis1[MAXN],dis2[MAXN];int r[MAXN];int pre1[MAXN],pre2[MAXN];int tnt=0;
struct EDGE{
    int u,v,w,nxt;
}a[MAXM];int dis[MAXN];int last[MAXN];

inline void add(int u,int v,int w){
    a[++tnt].u = u;a[tnt].v = v;a[tnt].w = w;a[tnt].nxt = last[u];last[u] = tnt;
}

inline void add(int u,int v,int w1,int w2){
    e[++cnt].u = u;e[cnt].v = v;e[cnt].w1 = w1;e[cnt].w2 = w2;e[cnt].nxt = head[u];head[u] = cnt;
}

queue<int>q;

inline void spfa1(){
    q.push(n);memset(dis1,inf,sizeof dis1);
    dis1[n] = 0;
    while(!q.empty()){
        int u = q.front();q.pop();r[u] = 0;
        for(int i=head[u];i;i=e[i].nxt){
            int v = e[i].v;
            if(dis1[v] > e[i].w1 + dis1[u]){
                pre1[v] = i;
                dis1[v] = e[i].w1 + dis1[u];
                if(!r[v]){
                    r[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}

inline void spfa2(){
    q.push(n);memset(dis2,inf,sizeof dis2);memset(r,0,sizeof r);
    dis2[n] = 0;
    while(!q.empty()){
        int u = q.front();q.pop();r[u] = 0;
        for(int i=head[u];i;i=e[i].nxt){
            int v = e[i].v;
            if(dis2[v] > e[i].w2 + dis2[u]){
                pre2[v] = i;
                dis2[v] = e[i].w2 + dis2[u];
                if(!r[v]){
                    r[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}

inline void spfa(){
    q.push(1);memset(dis,inf,sizeof dis);memset(r,0,sizeof r);
    dis[1] = 0;
    while(!q.empty()){
        int u = q.front();q.pop();r[u] = 0;
        for(int i=last[u];i;i=a[i].nxt){
            int v = a[i].v;
            if(dis[v] > a[i].w + dis[u]){
                dis[v] = a[i].w + dis[u];
                if(!r[v]){
                    r[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i){
        int u,v,w1,w2;scanf("%d%d%d%d",&u,&v,&w1,&w2);
        add(v,u,w1,w2);
        add(u,v,2);
    }
    spfa1();
    spfa2();
    for(int i=1;i<=n;++i){
        if(pre1[i] == pre2[i]) a[pre1[i]].w=0;
        if(pre1[i] != pre2[i]){
            a[pre1[i]].w = a[pre2[i]].w = 1;
        }
    }
    spfa();
    printf("%d",dis[n]);
    return 0;
}

T2 比赛

【题目描述】：
有三个小伙伴组队去参加 (ACM) 比赛，这场比赛共有(n)道题目，他们的比赛策略是这样的：每个队员都会对题目通看一遍，然后对每个题的难度进行估算，难度范围为 (1-9)。当然，由于每个队员的水平和特点， 他们对同一道题的估算不一定相同。
接下来他们会对所有题目进行分配。三个人分配的题目刚好是所有题目，且不会有交集，而且每个人分配的题目的编号必须是连续的，每人至少要 分一道题。请问，如何分配题目可以使得三个人拿到的题目的难度之和最小。每个人对自己 分配到的题目只按自己的估算值求和。

【输入格式】：
第一行一个数 (n)，表示题目的数量。
接下来有 (3) 行，每行表示一个学生，每行有 (n) 个数，表示该生对(n)道题的估算难度，难度介于 ([1,9])。

【输出格式】：
一个整数。表示最小的估算难度之和。

【样例输入1】：

3 
1 3 3 
1 1 1 
1 2 3

【样例输出1】：

4

【样例输出2】：

5
4 1 5 2 4 
3 5 5 1 1 
4 1 4 3 1

【样例输出2】：

11

【数据范围】：
对于 (20\%) 的数据：(3 <= N <= 1000)
对于 (100\%) 的数据：(3 <= N <= 200000)

思路：

先放个正解的思路吧，我虽然(AC)了但是是歪门邪道。。
考点:前缀和
序列分成三段，三个人可以分别挑一段，总的方案数是排列数(A_3^3)，于是有(6)种情况需要讨论。
对每种情况分别考虑，预处理每个人的前缀和：(SumX[])，(SumY[])，(SumZ[])
假设x，y，z三个人分别做([1,j], [j+1,i], [i+1,n] 1<=j<i<n)
(Total=(SumX[j]-0)+(SumY[i]-SumY[j])+(SumZ[n]-SumZ[i]))
(=SumZ[n]+(SumX[j]-SumY[j])+(SumY[i]-SumZ[i]))
(SumZ[n])是一个定值，我们只需讨论((SumY[i]-SumZ[i]))与((SumX[j]-SumY[j]))的关系

从左到右枚举(i)，记录i左边出现过的最小的((SumX[j]-SumY[j]) 1<=k<i)，更新答案
讨论一遍的时间复杂度为(O(n)),总共讨论(6)次，所以总的时间复杂度为(O(6n))

总时间复杂度为$O(6n) $

(std)：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
inline void _read(long long &d)
{
    char t=getchar();bool f=false;
    while(t<'0'||t>'9'){if(t=='-')f=true;t=getchar();}
    for(d=0;t>='0'&&t<='9';t=getchar())d=d*10+t-'0';
    if(f==true)d=-d;
}
long long ans=9999999999;
long long n;
long long sum[3][200005];
long long f[6][200005];
long long derta[6][200005];
void prepare()
{
    long long a=1;
    derta[0][a]=sum[0][a]-sum[1][a];
    derta[1][a]=sum[1][a]-sum[0][a];
    derta[2][a]=sum[0][a]-sum[2][a];
    derta[3][a]=sum[2][a]-sum[0][a];
    derta[4][a]=sum[2][a]-sum[1][a];
    derta[5][a]=sum[1][a]-sum[2][a];
    for(a=2;a<=n;a++)derta[0][a]=min(derta[0][a-1],sum[0][a]-sum[1][a]);
    for(a=2;a<=n;a++)derta[1][a]=min(derta[1][a-1],sum[1][a]-sum[0][a]);
    for(a=2;a<=n;a++)derta[2][a]=min(derta[2][a-1],sum[0][a]-sum[2][a]);
    for(a=2;a<=n;a++)derta[3][a]=min(derta[3][a-1],sum[2][a]-sum[0][a]);
    for(a=2;a<=n;a++)derta[4][a]=min(derta[4][a-1],sum[2][a]-sum[1][a]);
    for(a=2;a<=n;a++)derta[5][a]=min(derta[5][a-1],sum[1][a]-sum[2][a]);
}
void dealit()
{
    long long a,b,c,d,e;
    for(a=2;a<=n-1;a++)
    {
        b=sum[1][a]+derta[0][a-1]+sum[2][n]-sum[2][a];
        ans=min(b,ans);
    }
    for(a=2;a<=n-1;a++)
    {
        b=sum[1][a]+derta[4][a-1]+sum[0][n]-sum[0][a];
        ans=min(b,ans);
    }
    for(a=2;a<=n-1;a++)
    {
        b=sum[0][a]+derta[3][a-1]+sum[1][n]-sum[1][a];
        ans=min(b,ans);
    }
    for(a=2;a<=n-1;a++)
    {
        b=sum[0][a]+derta[1][a-1]+sum[2][n]-sum[2][a];
        ans=min(b,ans);
    }
    for(a=2;a<=n-1;a++)
    {
        b=sum[2][a]+derta[5][a-1]+sum[0][n]-sum[0][a];
        ans=min(b,ans);
    }
    for(a=2;a<=n-1;a++)
    {
        b=sum[2][a]+derta[2][a-1]+sum[1][n]-sum[1][a];
        ans=min(b,ans);
    }
}
int main()
{
    long long a,b,c,d,e;
    freopen("data10.in","r",stdin);
//  freopen("test.out","w",stdout);
    _read(n);
    for(a=0;a<=2;a++)
    {
        for(b=1;b<=n;b++)
        {
        _read(c);
        sum[a][b]=sum[a][b-1]+c;
        }
    }
    prepare();
    dealit();
    cout<<ans;
    return 0;
}

然而我。。。。。。。。。。。
仔细分析一下题目，我开始以为是二分，但是打了半个小时后觉得没法分，重新读题，发现这个题面可以转化一下：
给出一个(3*n)的矩阵，求把它从三行，分成连续的三个区间，所得的总和最小值
有没有点矩阵取数的感觉啊?

唯一的不同，就是转移方程。
(f[i][j] = min(f[i][j-1] , f[i-1][j-1]) + a[i][j])
然后把(6)种情况枚举一遍，输出最小值。。

#include<cstdio>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f

using namespace std;

const int MAXN = 200005;

int dif[4][MAXN];int dp[4][MAXN];

int main(){
    int n;scanf("%d",&n);int ans = inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            scanf("%d",&dif[i][j]);
        }
    }
    //round 1
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    //round 2
    memset(dp,0,sizeof dp);
    swap(dif[2] , dif[3]);
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    //round 3
    memset(dp,0,sizeof dp);
    swap(dif[1] , dif[3]);
    
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    //round 4
    memset(dp,0,sizeof dp);
    swap(dif[2] , dif[3]);
    
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    //round 5
    memset(dp,0,sizeof dp);
    swap(dif[1] , dif[3]);
    
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    //round 6
    memset(dp,0,sizeof dp);
    swap(dif[2] , dif[3]);
    
    dif[1][n] += inf;dif[1][n-1] += inf;
    dif[2][n] += inf;dif[1][1] -= inf;
    for(int i=1;i<=3;++i){
        for(int j=1;j<=n;++j){
            dp[i][j] = min(dp[i][j-1] , dp[i-1][j-1]) + dif[i][j];
        }
    }
    ans = min(ans , dp[3][n]+inf);
    dif[1][n] -= inf;dif[1][n-1] -= inf;
    dif[2][n] -= inf;dif[1][1] += inf;
    
    printf("%d",ans);
    return 0;
}

T3 浇花

【题面描述】：
(n) 个非负整数排成一行，每个数值为$ A_i$，数的位置不可改变。需要让所有的数都恰好等于 (h)。可进行的操作是：对任意长度的区间([i,j])中的每个数都加$ 1(，)i$ 和 (j) 也任选，但要求每个数只能作为一次区间的起点，也只能作为一次区间的终点。也即是说： 对任意的两个区 间([L_1,R_1]) 和 ([L_2,R_2]), 要求:(L1≠L2) 并且 (R1 ≠ R2).
请问有多少种不同的方式，使所有的数都等于 (h).
输出答案模 (1000000007 (10^9+7))后的余数。 两种方式被认为不同，只要两种方式所实施的操作的区间集合中，有一个区间不同即可。

【输入格式】：
第 (1)行：(2) 个整数 (n, h)
接下来$n $行，每行 (1) 个整数，表示(A_i)

【输出格式】：
第 (1)行：(1) 个整数，表示答案。

【样例输入1】：

3 2 
1 1 1

【样例输出1】：

4

【样例输入2】：

5 1
1 1 1 1 1

【样例输出2】：

1

【样例输入3】：

4 3 
3 2 1 1

【样例输出3】：

0

【数据范围】：
(30\%)的数据， (1≤n, h≤30)
(100\%)的数据，(1≤n, h≤2000 1≤Ai≤2000)

思路：

题解用的区间(dp)，但还有更优秀的解法。
题解：
考点 区间动态规划
类似于括号(dp)的讨论方式，讨论(i)的左边，选哪个数字作为区间的起点，更新(i)的值
(dp[i][k])表示从左往右讨论到第(i)个数字，(i)的左边有(k)个数字还未被用过(被当做区间的左起点), 的方案数。
分两种情况讨论：

情况(1)：(i)被别人更新(因为i前面的k个数，任选一个为区间起点，都可更新到(i))：
若(a[i]+k==h) 则$dp[i][k]=dp[i+1][k-1]*k+dp[i+1][k] $
说明，条件(a[i]+k==h),因为(i)左边有(k)个数字还没用过，那么以这(k)个数字作为区间左起点可以操作(k)次，每次都可以更新到(i)，更新(k)次，恰好就能使(a[i])变成(h)。
现在对于(i)而言，有两种选择， 使用(i)或者不使用(i)。
若用(i)作为区间右端点，因为i只能当一次区间终点，所以只能从前(k)个中选一个来与它配对，故有(k)种方案，(k)个数中(i)选了一个，对于(i+1)它左边就只有(k-1)个未使用的数了，数量总数为(k*dp[i+1][k-1]) 。
注意，这里(i)不能再作为区间的左端点了，这样的话会导致(i)被多更新一次，高度变成(h+1)
若不用(i)作为区间端点，则方案数为(dp[i+1][k])

情况(2)：(i)作为区间起点去更新别人
若(a[i]+k+1=h)则(dp[i][k]=dp[i+1][k]*(k+1)+dp[i+1][k+1])
说明，因为(i)前面有(k)个数未被当做左起点使用，全部操作都只能把(a[i])更新到(h-1)这个高度，那么(i)号点必须自己作为某区间的左起点更新一次，在更新这个区间的同时把自己的高度也更新(1)，达到(h)。
这样，对于下一个数(i+1)而言，算上(i)号点，它左侧有(k+1)个点可选做区间左端点，任选一个选后剩下(k)个点，状态(dp[i+1][k])
若不用(i)作为区间左端点，则方案数为(dp[i+1][k+1])

时间复杂度(O(n^2)),实现时采用记忆化搜索比较方便。

#include<iostream>
#include<cstdio>

using namespace std;
#define MOD 1000000007

long long dp[2010][2010];
int a[2010];
inline void add(long long &a,long long b){
   a += b;
   a %= MOD;
}
int main()
{
    int n,h;

     cin >> n >> h;

     for (int i = 1; i <= n ;i ++)
         cin >> a[i];

     dp[1][0] = (a[1] == h || a[1] + 1 == h?1:0);
     dp[1][1] = (a[1] + 1 == h?1:0);

     for (int i = 2;i <= n + 1; i ++)
      for (int open = max(0,h - a[i]- 1); open <= min(h - a[i],i) ; open ++){
          if (a[i] + open == h){
             add(dp[i][open] , dp[i - 1][open]);
             if (open > 0)
                add(dp[i][open] , dp[i - 1][open - 1]);
          }
          if (open + a[i] + 1 == h){
               add(dp[i][open] , dp[i - 1][open + 1] * (open + 1));
               add(dp[i][open] , dp[i - 1][open]);
               add(dp[i][open] , dp[i - 1][open] * open);
          }
      }

     cout << dp[n][0] << endl;
     return 0;
}

什么(O(n^2))，明明(O(n))好不好
详见：这个懒得写了(233)

#include<cstdio>
using namespace std;
typedef long long ll;

int n,m;

const int MAXN = 2005;
const ll mod = 1e9+7;

int a[MAXN];int b[MAXN];

inline int ABS(int x){return x < 0 ? -x : x;}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i){
        scanf("%d",&a[i]);
        a[i] = m - a[i];
        if(i == 1 && a[i] > 1) {puts("0");return 0;}
        if(i == n && a[i] > 1) {puts("0");return 0;};
        if(a[i] < 0) {puts("0");return 0;}
    }
    for(int i=1;i<=n;++i){
        b[i] = a[i] - a[i-1];
        if(ABS(b[i]) > 1){puts("0");return 0;}
    }
    
    ll cnt = 0;ll ans = 1;
    for(int i=1;i<=n;++i){
        if(b[i] == 1) cnt++;
        if(b[i] == -1) ans = (ans * cnt) % mod,cnt--;
        if(b[i] == 0) ans = (ans * (cnt + 1)) % mod;
    }
    printf("%lld",ans);
    return 0;
}

我还是太弱了。。