[1018NOIP模拟赛]

题目描述 Description###

精灵王国要同侵略 $ Bzeroth $ 大陆的地灾军团作战了。

众所周知，精灵王国有 $N$ 座美丽的城市，它们以一个环形排列在$ Bzeroth$ 的大陆上。为了补充军需，王国财政部决定从这$ N $ 座城市的商人们腰包中征用物资，其中第$ i $ 座城市的商人们共可以提供 $ A[i] $ 单位的物资。当征粮队征集物资的时候，他们发现一件出乎意料的事情：如果他们征集了第 $i$ 座城市的物资，那么与第 $i $座城市相邻的两座城市（$1 $ 号城市与 $N$ 号城市相邻）里的商人都会逃跑，即征粮队不能再到这两座城市征集物资。财政部得知这一消息后迅速召开了会议，决定让精灵王国最好的工程师——你，来设计出最优的征集方案，使得联军能够征集到的物资尽可能多。

输入描述 Input Description###

第一行一个正整数$ N $ 。

第二行$ N $ 个正整数，第 i 个数为$ A[i] $ 。

输出描述 Output Description###

输出最优情况下征集到的物资总和。

样例输入 Sample Input###

5 2 3 4 5 5

样例输出 Sample Output###

数据范围及提示 Data Size & Hint###

测试数据编号数据范围其他限制

1 - 5 2 ≤ N ≤ 20

6 - 7 2 ≤ N ≤ 2501

8 - 9 2 ≤ N ≤ 152501 所有 $ A[i] $均相等

10 2 ≤ N ≤ 152501

对于 100%的数据：$1 ≤ A[i] ≤ 10^9 $ 。

之前的一些废话###

没有废话

题解###

环形灭虫子，先考虑直线情况, $ dp[i][0] $ 表示第i个不选的最大收益，$ dp[i][1] $ 表示第i个选的最大收益，转移的话是$dp_{i,1}=max\texttt{\{}0,dp_{i-1,0} \texttt{\}}+a_i$,$dp_{i,0}=max\texttt{\{}dp_{i-1,1},dp_{i-1,0} \texttt{\}};$

若是环形的话，则强行令端头选，端头不选各DP一次。

代码###

#include<iostream>

#include<algorithm>

#include<cmath>

#include<queue>

#include<cstring>

#include<cstdio>

using namespace std;

typedef long long LL;

#define mem(a,b) memset(a,b,sizeof(a))

typedef pair<int,int> PII;

inline int read()

{

	int x=0,f=1;char c=getchar();

	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}

	while(isdigit(c)){x=x*10+c-'0';c=getchar();}

	return x*f;

}

const int maxn=152510,oo=2147483647;

int n,a[maxn];

LL dp[maxn][2],ans;

int main()

{

	n=read();

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

	dp[1][1]=a[1];dp[1][0]=-oo;

	for(int i=2;i<=n;i++)

	{

		dp[i][1]=max(0ll,dp[i-1][0])+a[i];

		dp[i][0]=max(dp[i-1][0],dp[i-1][1]);

	}

	ans=dp[n][0];

	dp[1][1]=-oo;dp[1][0]=0;

	for(int i=2;i<=n;i++)

	{

		dp[i][1]=max(0ll,dp[i-1][0])+a[i];

		dp[i][0]=max(dp[i-1][0],dp[i-1][1]);

	}

	ans=max(ans,max(dp[n][0],dp[n][1]));

	printf("%lld\n",ans);

	return 0;

}

总结###

没有总结

题目描述 Description###

每一个生活在$ Bzeroth $ 大陆的精灵都知道，若想毁灭他们深爱的这片土地，必须要先摧毁守护 $ Bzeroth $ 大陆的$ N $ 个能量核心。

这 $ N $ 个能量核心由诸神修建的 $ M $ 条秩序神链沟通，其中第$ i $ 条秩序神链沟通了第$ u_i $ 和第 $ v_i $个核心，稳定程度为 $ w_i$ 。最开始，这 $ N $ 个能量核心是连通的（即任意两个能量核心均能通过神链直接或间接沟通）。地灾军团的军师黑袍得知，他们可以摧毁若干神链使得这 $ N $ 个能量核心恰好被分成两个连通块，从而削弱 $ Bzeroth $ 大陆的防卫能量。由于被摧毁后的防卫能量等于未被摧毁的神链的稳定程度之和，所以他找到了精灵王国最好的工程师，同时也是地灾军团潜伏在 $ Bzeroth $ 大陆多年的间谍——你，来设计出最优的方案，使得未被摧毁的神链的稳定程度之和最小。

输入描述 Input Description###

第一行为 2 个整数 $ N $ 、$ M $ 。

接下来 M 行每行三个正整数 $ u_i $ 、$ v_i $ 、 $ w_i $ 。

输出描述 Output Description###

输出最优情况下未被摧毁的神链的稳定程度之和。

样例输入 Sample Input###

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

样例输出 Sample Output###

数据范围及提示 Data Size & Hint###

测试数据编号数据范围其他限制

1 - 5 2 ≤ N、M ≤ 15

6 - 7 2 ≤ N、M ≤ 152501 2 ≤ N ≤ 15

8 2 ≤ N、M ≤ 152501 M = N - 1

9 2 ≤ N、M ≤ 152501 M = N

10 2 ≤ N、M ≤ 152501

对于 100%的数据：$ 1 ≤ u_i、v_i≤ N，1 ≤ w_i ≤ 10^9 $ 。

之前的一些废话###

没有废话

题解###

随便试一两个图就发现答案是原图的最小生成树-最小生成树上的最大权值边

代码###

#include<iostream>

#include<algorithm>

#include<cmath>

#include<queue>

#include<cstring>

#include<cstdio>

using namespace std;

typedef long long LL;

#define mem(a,b) memset(a,b,sizeof(a))

typedef pair<int,int> PII;

typedef pair<int,PII> PIP;

#define X first

#define Y second

#define MP make_pair

inline int read()

{

	int x=0,f=1;char c=getchar();

	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}

	while(isdigit(c)){x=x*10+c-'0';c=getchar();}

	return x*f;

}

const int maxn=152510,oo=2147483647;

int n,m,a,b,c,f[maxn];

LL sum,MAX;

PIP E[maxn];

int getf(int x){return f[x]==x ? x : f[x]=getf(f[x]);}

void merge(int a,int b)

{

	int x=getf(a),y=getf(b);

	if(x!=y)f[x]=y;

}

int main()

{

	n=read();m=read();

	for(int i=1;i<=n;i++)f[i]=i;

	for(int i=1;i<=m;i++)a=read(),b=read(),c=read(),E[i]=MP(c,MP(a,b));

	sort(E+1,E+m+1);

	for(int i=1;i<=m;i++)

	{

		int u=E[i].Y.X,v=E[i].Y.Y;

		if(getf(u)!=getf(v))

		{

			sum+=E[i].X;

			MAX=max(MAX,(LL)E[i].X);

			merge(u,v);

		}

	}

	printf("%lld\n",sum-MAX);

	return 0;

}

总结###

没有总结

题目描述 Description###

精灵心目中亘古永恒的能量核心崩溃的那一刻，$ Bzeroth $ 大陆的每个精灵都明白，他们的家园已经到了最后的时刻。

就在这危难关头，诸神天降神谕，传下最终兵器——潘少拉魔盒。然而当精灵们准备打开魔盒时，魔盒的守护灵出现在精灵们面前：“如果你们想要拯救世界，必须要先解决这个困难的问题：定义一个 N 阶数列 A 为神奇数列当且仅当对所有$ 2 ≤i ≤ N - 1 $ ，都有 $ A_i-1 + A_i+1 ≥ 2 × A_i $ 。现在有一个$ N $ 阶正整数列$ B $ ，请计算将 $ B $ 数列均匀随机打乱之后，得到的数列是神奇数列的概率 $ P $ 。你只需要输出 $ P × (N!) mod 998244353 $ 的结果即可。（显然 $ P × (N!) $ 一定是个整数）。”

输入描述 Input Description###

第一行为 1 个正整数 $ N $。

第二行为 N 个正整数 $ A_i $。

输出描述 Output Description###

输出 $ P × (N!) mod 998244353 $ 的结果。

样例输入 Sample Input###

4 1 2 1 3

样例输出 Sample Output###

数据范围及提示 Data Size & Hint###

对于 50%的数据：3 ≤ N ≤ 10。

对于 80%的数据：3 ≤ N ≤ 20。

对于 100%的数据：3 ≤ N ≤ 40，$ 1 ≤A_i ≤ 10^9 $ 。

之前的一些废话###

没有废话

题解###

发现当且仅当A数组是一个下凸函数时才满足题意

考试时候写的是80分，排个序是肯定的，然后我们确定了最小值，开始往两边依次递增的填数，用 $ 2^n $ 枚举在左边的数，然后判一判是否合法。最后算出总方案数乘以最小数个数的阶乘即可。正解在这基础上稍微改一下即可，往两边插值的时候判断能否插入只与左右两端最大值次大值有关，设计状态 $ dp[i][j][k][l] $ 表示当前序列最左边两个数分别是$ a_i $ 和$ a_j $ ，最右边两个数分别是$ a_k $ 和$ a_l $ 的合法序列数，转移显然。复杂度 $O(n^4)$

代码###

#include<iostream>

#include<algorithm>

#include<cmath>

#include<queue>

#include<cstring>

#include<cstdio>

using namespace std;

typedef long long LL;

#define mem(a,b) memset(a,b,sizeof(a))

typedef pair<int,int> PII;

typedef pair<int,PII> PIP;

const int MOD=998244353,maxn=42;

inline int read()

{

	int x=0,f=1;char c=getchar();

	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}

	while(isdigit(c)){x=x*10+c-'0';c=getchar();}

	return x*f;

}

int n,a[maxn],sum=1,jc[maxn],dp[maxn][maxn][maxn][maxn],ans;

int main()

{

    n=read();

    jc[0]=1;

    for(int i=1;i<=n;i++)a[i]=read(),jc[i]=((LL)jc[i-1]*(LL)i)%MOD;

    sort(a+1,a+n+1);

    for(int i=2;i<=n;i++)

	{

		if(a[i]!=a[i-1])break;

		sum++;

	}

	for(int i=sum+1;i<=n;i++)a[i-sum+1]=a[i];

	dp[1][0][1][0]=1;

	n=n-sum+1;

	for(int i=1;i<=n;i++)

	    for(int j=0;j<i;j++)

		    for(int k=1;k<=n;k++)

			    for(int l=0;l<k;l++)

			    {

			    	int pos=max(i,k)+1;

			    	if(pos==n+1){ans=(ans+dp[i][j][k][l])%MOD;continue;}

			    	if(2*a[i]<=a[pos]+a[j] || i==1)dp[pos][i][k][l]=(dp[pos][i][k][l]+dp[i][j][k][l])%MOD;

			    	if(2*a[k]<=a[pos]+a[l] || k==1)dp[i][j][pos][k]=(dp[i][j][pos][k]+dp[i][j][k][l])%MOD;

			    }

	printf("%d\n",((LL)ans*(LL)jc[sum])%MOD);

	return 0;

}

总结###

设计DP状态时要充分考虑哪些状态是真正需要用到的。