暑期训练第四次团队赛

A - Longest!!! POJ - 2533 （dp）

A numeric sequence of ai is ordered if a1 < a2 < … < aN. Let the subsequence of the given numeric sequence (a1, a2, …, aN) be any sequence (ai1, ai2, …, aiK), where 1 <= i1 < i2 < … < iK <= N. For example, sequence (1, 7, 3, 5, 9, 4, 8) has ordered subsequences, e. g., (1, 7), (3, 4, 8) and many others. All longest ordered subsequences are of length 4, e. g., (1, 3, 5, 8).

Your program, when given the numeric sequence, must find the length of its longest ordered subsequence.
Input
The first line of input file contains the length of sequence N. The second line contains the elements of sequence - N integers in the range from 0 to 10000 each, separated by spaces. 1 <= N <= 1000
Output
Output file must contain a single integer - the length of the longest ordered subsequence of the given sequence.
Sample Input
7
1 7 3 5 9 4 8
Sample Output
4
题目大意：
找最长的连续的升序字串。
AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
const int N=1100;
int a[N];
int dp[N];	//存放以i为终点 前面最长的连续递升子串的长度 
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)	cin>>a[i];
	
	int res=1;
	for(int i=1;i<=n;i++)	//终点 
	{
		dp[i]=1;
		for(int j=1;j<i;j++)	//遍历i之前的所有数字 
		{
			if(a[j]<a[i])
				dp[i]=max(dp[i],dp[j]+1);	//状态转移方程 
				//找到符合条件的最大长度子串 
		}
		res=max(res,dp[i]);
	}
	cout<<res<<endl;
	return 0;
}
/*
模拟：
7
1 7 3 5 9 4 8

1
i=1
dp[1]=1;(1)

7
i=2
dp[2]=dp[1]+1=2;(1 7)

3
i=3
dp[3]=dp[1]+1=2;(1 3)

5
i=4
dp[4]=dp[3]+1=3;(1 3 5)

9
i=5
dp[5]=dp[4]+1=4;(1 3 5 9)

4
i=6
dp[6]=dp[3]+1=3;(1 3 4)

8
i=7
dp[7]=dp[4]+1;(1 3 5 8)
*/ 

E - 回文？ CodeForces - 805B (思维)

对于一个给定的 n 想获得一个有 n 字符的字符串，每个字符都是 ‘a’, ‘b’ 或 ‘c’, 没有长度为 3 回文子串. 例如，字符串 “abc” 和"abca" 适合他, 而字符串 “aba” 则不符合. 希望字符串中的字母 ‘c’ 尽量少。

Input
第一行包含单个整数 n (1 ≤ n ≤ 2·105) — 表示字符串的长度。

Output
输出满足所有约束的字符串。

如果有多个答案，输出它们中的任何一个。

Example
Input
2
Output
aa
Input
3
Output
bba
AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int main()
{
	string s="aabb";
	int n;
	cin>>n;
	int t=n/4,tt=n%4;
	if(t>0)	
	{
		for(int i=0;i<t;i++)
			cout<<s;
	}
	for(int i=0;i<tt;i++)
		cout<<s[i];
	cout<<endl;
	return 0;
}

F - An interesting sequence CodeForces - 1557A （思维）

There are n numbers (which may contain negative numbers). Fanfan wants to divide them into two non empty subsequences a and b, so that all the numbers in the array come from one of the subsequences exactly, and the value of F(a)+F(b) is the maximum possible value, where F(x) is the average of the subsequence x.

A sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.

The average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.

For example, the average of [1,5,6] is (1+5+6)/3 = 12/3 = 4, so F([1,5,6]) = 4.

Input
The first line contains a single integer t (1 <= t <= 10^3)— the number of test cases. Each test case consists of two lines.

The first line contains a single integer n (2 <= n <= 10^5).

The second line contains n integers a1, a2, …, an (-10^9 <= ai <= 10^9).

It is guaranteed that the sum of n over all test cases does not exceed 3*10^5.

Output
For each test case, print a single value — the maximum value that Fanfan can achieve.

Your answer is considered correct if its absolute or relative error does not exceed 10^-6.

Example
Input
4
3
3 1 2
3
-7 -6 -6
3
2 2 2
4
17 3 5 -3
Output
4.500000000
-12.500000000
4.000000000
18.666666667

AC代码：
想要得到最大答案，则两个子序列肯定都越大越好，让最大的数字放在一个序列a，剩余所有数字放在另一个序列b时最优（这个时候如果从b序列抽出数字（大）加入a序列，a、b的平均值都会减小）

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int t,n;
double a[N],pre[N];

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		double ans=0;
		memset(pre,0,sizeof(pre));
		memset(a,0,sizeof(a));
		
		scanf("%d",&n);
		for(int i=1;i<=n;i++)	scanf("%lf",&a[i]);
		sort(a+1,a+n+1);
		for(int i=1;i<=n;i++)	pre[i]=pre[i-1]+a[i];
		ans=a[n]+(pre[n-1]/(n-1));
		printf("%.9lf\n",ans);
	}
	return 0;
}

I - YES OR NO CodeForces - 1324B （思维）

Your task is to determine whether sequence X has an echo subsequence of length at least 3.
Subsequence: Remove k(0<=k<=n) elements from a sequence x of length n to obtain a new sequence that is a subsequence of x

Input
The first line of input contains an integer T (1≤t≤100) representing the number of test cases. The next 2T line describes the test case. The first line of the test case contains an integer n (3≤n≤5000) representing the length of the array X. The second line of the test case contains n integers X1, x2… Xn of 1≤xi≤n, where Xi is the i-th element of x.
Insure all test cases(∑n≤5000）。

Output
For each test case, print the answer “YES” (without quotes) if one of the subsequences of x is at least 3 in length and palindrome, or “NO” otherwise.

Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of this example, the subsequence [1,2,1] of array x is a palindrome.

In the second test case of the example, the array x has two subsequences of length 3, which are palindromes: [2,3,2] and [2,2,2].（！！！！这点很重要！！！子串不需要连续只要左右不相连有两个字符相等就符合题意）

In the third test case of this example, array X has no subsequence of at least 3 length and is palindrome.

In the fourth test case of the example, a subsequence of length 4 of array x is a palindrome: [1,2,2,1].

In the fifth test case of the example, the array X has no subsequence of length at least 3 and is palindrome.
AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int N=5050;
int t,n;
int x[N];
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		memset(x,0,sizeof(x));
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
			scanf("%d",&x[i]);
		bool flag=0;
		for(int i=1;i<=n-2;i++)
		{
			int l=i,r=n;
			while(x[l]!=x[r]&&r>l)	r--;
			if(x[l]==x[r]&&l<r-1)	//只要有两个字符相同而且之间距离大于1就行 
			{
				flag=1;
				break;
			}
		}
		if(flag)	printf("YES\n");
		else	printf("NO\n");
	}
	return 0;
}

K - w(ﾟДﾟ)w坐大牢 POJ - 3984 （bfs+记录路径）⭐⭐⭐

Description
w(ﾟДﾟ)w坐大牢了！他被叫去学习1+1=3这个问题，可是5*5的房间对他来说实在是太大了，他过去就记不住路了，没办法回去，因此他要记录一下自己走过的路，而且一定要是最短的路线。
定义左上角为w(ﾟДﾟ)w的房间，右下角为学习的房间。

Input
一个5 × 5的二维数组，表示w(ﾟДﾟ)w的牢房。数据保证有唯一解。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
AC代码：
比赛时想了好久想不出怎么记录路径。。。。
定义一个数组保存前驱节点就好了

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
int step=0,mp[6][6],dis[6][6];
int dir[4][2]={0,1,0,-1,1,0,-1,0};

struct node
{
	int x,y;
}pre[6][6];		//记录前驱节点，即该点是由哪个点拓展出来的 

bool judge(int x,int y)
{
	return x>=0&&x<5&&y>=0&&y<5;
}

void bfs(int x,int y)
{
	queue<node> q;
	q.push({x,y});
	dis[x][y]=0;
	
	while(!q.empty())
	{
		node now=q.front();
		int nx=now.x;
		int ny=now.y;
		q.pop();
		if(nx==0&&ny==0)	return;
		if(judge(nx,ny)==0)	continue;
		
		for(int i=0;i<4;i++)
		{
			int tx=nx+dir[i][0];
			int ty=ny+dir[i][1];
			if(judge(tx,ty)&&mp[tx][ty]==0)
			{
				mp[tx][ty]=1;
				pre[tx][ty]=now;
				q.push({tx,ty});
				dis[tx][ty]=dis[nx][ny]+1;
			}
		}
	}
	return ;
}

int main()
{
	for(int i=0;i<5;i++)
	{
		for(int j=0;j<5;j++)
			cin>>mp[i][j];
	}
	bfs(4,4);	//为了便于输出路径，倒着遍历 
	
	cout<<"(0, 0)"<<endl;
	int nx=0;
	int ny=0;
	step=dis[0][0];
	while(step--)
	{
		int x=pre[nx][ny].x;
		int y=pre[nx][ny].y;
		cout<<"("<<x<<", "<<y<<")"<<endl;
		nx=x;
		ny=y;
	}
	
	return 0;
}

L - w(ﾟДﾟ)w唱电音 HDU - 1794 （暴力）（二维数组覆盖次数）⭐⭐

Description
w(ﾟДﾟ)w有一个N * N的方形乐器，这是他的电音神器，他能用它唱出非常电的电音。乐器的每一个格子中，都有一个电值，代表了这个格子电的程度(小于32768)，w(ﾟДﾟ)w所能创作出最电的电音的大小，就是其中任何一个S * S的方格中电值的总和(1<=S<=N)。但是，其中有K个格子竟然没电了，电值变成了0！w(ﾟДﾟ)w很不满意，这样他就不够电了，因此他找人买了M(最多10000，大于K)块儿电，打算填补上空格子。可是凡凡被坑了，这一批电是次品，里面的电值有高有低，于是他向你求助，想知道他最多能增加电音的大小是多少。

Input
第一行输入T，代表有T次被坑，向你求助。（T小于101）
对于每一个测试数据，第一行输入N（小于31），随后输入一个N * N的矩阵，其中含有0的元素。随后给一个M，输入M个整数（小于32768）。

Output
对于每次被坑，请输出最大能增大电音的值。

Sample Input
1
3
1 2 3
4 0 2
0 2 7
4
2 9 4 7

Sample Output
75
AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
const int N=35;
const int M=10010;
int t,n,m;
int mp[N][N],cnt[N][N];
int s[M],a[M];	//注意数组范围 

bool cmp(int a,int b)
{
	return a>b;
}

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		memset(cnt,0,sizeof(cnt));
		memset(mp,0,sizeof(mp));
//		memset(s,0,sizeof(s));
//		memset(a,0,sizeof(a));
		
		for(int s=1;s<=n;s++)
		{
			for(int i=1;i<=n;i++)
			{
				if(i+s-1>n)	break;
				for(int j=1;j<=n;j++)
				{
					if(j+s-1>n)	break;
					for(int a=i;a<i+s&&a<=n;a++)
					{
						for(int b=j;b<j+s&&b<=n;b++)
							cnt[a][b]++;
					}
				}
			}
		}
		
		int kk=0;
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				scanf("%d",&mp[i][j]);
				if(mp[i][j]==0)
					s[kk++]=cnt[i][j];
			}
//			cout<<endl;
		}
		sort(s,s+kk,cmp);
		
		scanf("%d",&m);
		for(int i=0;i<m;i++)
			scanf("%d",&a[i]);
		sort(a,a+m,cmp);
		
		ll ans=0;
		for(int i=0;i<kk;i++)
		{
			ans+=((ll)s[i]*a[i]);
			m--;
			if(m==0)	break;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

G - w(ﾟДﾟ)w爱跑酷 POJ - 1088 （dfs+dp）（记忆化搜索）⭐⭐⭐

w(ﾟДﾟ)w酷爱跑酷，但是w(ﾟДﾟ)w的体能不是很好，所以w(ﾟДﾟ)w只能从高的地点跳向低的地方，因为这样比较省力。这天w(ﾟДﾟ)w和明明正在进行一场比赛，两个人比谁跑的更远，w(ﾟДﾟ)w想知道一个区域中他可以跑的最长的跑酷距离。区域由一个二维数组给出。数组的每个数字代表地点的高度。下面是一个例子
1 2 3 4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

可以从某个点跑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可行的路线为24-17-16-1。当然25-24-23-…-3-2-1更长。事实上，这是最长的一条。
Input
输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。
Output
输出最长跑酷路线的长度。
Sample Input
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
Sample Output
25
AC代码：

//记忆化搜索 
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
const int N=110;
int r,c,mp[N][N];
int dis[N][N];	//记录以该点为起点可以走的最长路径 
int dir[4][2]={0,1,0,-1,1,0,-1,0};

bool judge(int x,int y)
{
	return x>=0&&y>=0&&x<r&&y<c;
}

int dfs(int x,int y)
{
	if(dis[x][y]>0)		//如果已经记录过了 
		return dis[x][y];	//直接返回 
	
	dis[x][y]=1;
	for(int i=0;i<4;i++)
	{
		int tx=x+dir[i][0];
		int ty=y+dir[i][1];
		
		if(judge(tx,ty)&&mp[tx][ty]<mp[x][y])
			dis[x][y]=max(dis[x][y],dfs(tx,ty)+1);
	}
	
	return dis[x][y];
}

int main()
{
	cin>>r>>c;
	for(int i=0;i<r;i++)
	{
		for(int j=0;j<c;j++)
			cin>>mp[i][j];
	}
	memset(dis,0,sizeof(dis));
	int res=0;
	for(int i=0;i<r;i++)	
	{
		for(int j=0;j<c;j++)
			res=max(res,dfs(i,j));	//dfs每个点 查询每个点可以走的最长路径 
	}
	cout<<res<<endl;
	return 0;
}

H - 放手吧老王，外面全是共享单车 CodeForces - 95C （二次建图+Dijkstra）⭐⭐⭐

老王非常喜欢国足。一天，他要去观看一场足球比赛。由于老王很穷，并且没有车子，所以他能骑共享单车。这个城市有n个路口，其中一些道路由双向连接。每路口之间的长度由若干米的正整数定义;路口之间可以有不同的长度。

最初，每个路口只有一辆共享单车停在那里。从第 i 个路口出发，由于每个共享单车电量不唯一，即所行驶距离不超过ti米，老王骑车(可能要经过几个中间路口)到其他路口。 此外，乘坐的费用不取决于距离，而是等于 ci 元。由于道路中间没有共享单车，即老王不能停在路中间。每辆单车只能使用一次。老王只能在它最初所在的路口使用共享单车。

目前老王位于 x 路口，足球场位于 y 路口，请你帮助老王确定骑车到球场需要的最低金额。

输入
第一行输入包含 2 个整数 n 和 m (1 ≤ n ≤ 1000, 0 ≤ m ≤ 1000)，分别对应的是城市中路口与路口之间道路的数量。路口编号范围是从 1 到 n。

接下来的一行包含 2 个整数 x 和 y (1 ≤ x, y ≤ n)。它们分别是初始路口和终点路口的编号。

接下来的 m 行包含道路的描述。 每条路由 3 个整数描述： ui, vi, wi (1 ≤ ui, vi ≤ n, 1 ≤ wi ≤ 109) —— 他们分别代表道路连接的路口编号和道路长度。

接下来的 n 行包含 n 对整数 ti 和 ci (1 ≤ ti, ci ≤ 109)，描述了在第 i 个路口的共享单车所能到达的最远距离和所需要花费的金额。

一条路不可能只连接1个路口，但是在一对路口之间可以有不止一条路。每一行中的所有连续数字都由一个空格字符分隔。

输出
如果老王不能到达终点，输出 -1，否则，输出最少花费的金额。

在C++中请不要用 %lld 说明符读取或写入64位整数，推荐使用标准输入输出流 cin, cout 或者 %I64d 说明符。

样例
输入
4 4
1 3
1 2 3
1 4 1
2 4 1
2 3 5
2 7
7 2
1 2
7 7
输出
9
提示
最佳路径 —— 从路口 1 到路口 2 (经过路口 4)，然后从路口 2 到路口3，共花费 7+2=9 元。
AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <queue>
using namespace std;
typedef long long ll;
const ll INF=1e18;
const int N=1100;

int n,m,x,y;
ll dis[N][N],cost[N];
int head[N];
int cnt=0,cntt=0;
bool vis[N][N]={0},viss[N]={0};

struct edge
{
	int to,next;
	ll w;
}e[N*N],E[N*N];
//!!注意这里e[]和E[]的范围
//不知道为啥开N会RE 

struct node
{
	int id;
	ll dis;
	bool operator < (const node&o)const
	{
		return dis>o.dis;
	}
};

void add(int u,int v,ll w)
{
	e[cnt].to=v;
	e[cnt].w=w;
	e[cnt].next=head[u];
	head[u]=cnt++;
}
void Add(int u,int v,ll w)
{
	E[cntt].to=v;
	E[cntt].w=w;
	E[cntt].next=head[u];
	head[u]=cntt++;
}

void dijkstra(int x)	//x点到其他所有点的最短路 
{
	for(int i=1;i<N;i++)	dis[x][i]=INF;
	priority_queue<node> q;
	dis[x][x]=0;
	q.push({x,0});
	
	while(!q.empty())
	{
		node now=q.top();
		int nx=now.id;
		q.pop();
		
		if(vis[x][nx])	continue;
		vis[x][nx]=1;
		
		for(int i=head[nx];i!=-1;i=e[i].next)
		{
			int tx=e[i].to;
			
			if(dis[x][tx]>dis[x][nx]+e[i].w)
			{
				dis[x][tx]=dis[x][nx]+e[i].w;
				if(vis[x][tx])	continue;
				q.push({tx,dis[x][tx]});
			}
		} 
	}
}

void Dijkstra(int x)	//x点到其他所有点的最短花费 
{
	for(int i=1;i<N;i++)	cost[i]=INF;
	priority_queue<node> q;
	cost[x]=0;
	q.push({x,0});
	
	while(!q.empty())
	{
		node now=q.top();
		int nx=now.id;
		q.pop();
		
		if(viss[nx])	continue;
		viss[nx]=1;
		
		for(int i=head[nx];i!=-1;i=E[i].next)
		{
			int tx=E[i].to;
			
			if(cost[tx]>cost[nx]+E[i].w)
			{
				cost[tx]=cost[nx]+E[i].w;
				if(viss[tx])	continue;
				q.push({tx,cost[tx]});
			}
		} 
	}
}

int main()
{
	cin>>n>>m;
	cin>>x>>y;
	
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++)
	{
		int u,v;
		ll w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	for(int i=1;i<=n;i++)	dijkstra(i);	//求出每个点到其余所有点的最短距离 
	
	//重新建图，权值变为费用 
	memset(head,-1,sizeof(head));
	for(int i=1;i<=n;i++)
	{
		int t,c;
		cin>>t>>c;
		for(int j=1;j<=n;j++)
		{
			if(dis[i][j]<=t&&i!=j)	//如果可以从i到j 
			{
				//注意这里是单向的 
				Add(i,j,c);
			}
		}
	}
	Dijkstra(x);
	
	if(cost[y]==INF)	cout<<-1<<endl;
	else	cout<<cost[y]<<endl;	
	return 0;
}

J - 碳烤皮皮虾们的晨会 HDU - 3047 （带权值并查集）⭐⭐⭐

自从上次的海上集体活动之后，皮皮虾要举行晨会。
皮皮虾们不会制定什么座位表之类的东西，但是虾王皮皮签给了你一些数据。
给出n只虾和m个关系,关系为A B x表示A位置若为i,则B位置在A顺时针加x的位置。
如果一个关系在前面给出的关系中矛盾,则称其不成立。求不成立关系个数。
Input
有多组数据，对每一组数据：
第一行有两个整数N，M(N(1<=N<=50,000), M(0<=M<=100,000))——N 代表给出的皮皮虾的编号为 1~ N，M代表两皮皮虾之间关系的数量；
接下来M行每行给出3个整数x，y，d——代表x虾和y虾之间有d 的距离；
现在虾王要求你找出其中的不成立关系输出其个数(即x，y之间的距离和d不同)。

Output
对每一组数据：
输出一个整数，代表错误的关系的个数。
Sample Input
10 10
1 2 150
3 4 200
1 5 270
2 6 200
6 5 80
4 7 150
8 9 100
4 8 50
1 7 100
9 2 100
Sample Output
2
AC代码：

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
const int N=5e4+10;
int n,m;
int f[N];	//存放父亲节点 
ll dis[N];	//存放到祖宗节点的绝对距离 

int fd(int x)
{
	if(f[x]!=x)
	{
		int t=f[x];
		f[x]=fd(f[x]);
		dis[x]+=dis[t];		//查询的同时更新距离 
	}
	return f[x];
}

int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		for(int i=1;i<=n;i++)
		{
			f[i]=i;
			dis[i]=0;
		}
		int ans=0;
		while(m--)
		{
			int x,y;
			ll d;
			scanf("%d%d%lld",&x,&y,&d);
			int fx=fd(x);
			int fy=fd(y);
			if(fx!=fy)	//如果不在一个集合 合并 
			{
				f[fy]=fx;
				dis[fy]=dis[x]+d-dis[y];
			}
			else
			{
				if(dis[y]!=dis[x]+d)
					ans++;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}