YCOJ5月26日赛

1.因数的个数

Description

给定正整数N，求N的阶乘N!的因数的个数。由于答案可能非常巨大，只需要输出模109+710^9+7109+7后的余数。

Input

第1行：1个整数，表示N

Output

第1行：1个整数，表示答案。注意，答案要模1000000007

Sample Input 1

3

Sample Output 1

4

Sample Input 2

1000

Sample Output 2

972926972

开始一看，哇，好简单~蒟蒻的未来到了。
然而，不到10分钟，情况很尴尬。
关于样例1，虽然正确了，But，只有样例1正确了。。。
样例二什么鬼？
数据太大，一直卡着。。。
考完后，在A了它。
而实际它就是一道数论题。

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

int n;
int a[10100];

long long ans=1;

void solve(int x){
	for(int i=2;i<=x;i++){	
		while(x%i==0){
			x/=i;
			a[i]++;
		}
	}
}

int main(){
	

	cin >> n;
    for(int i=2;i<=n;i++){
    	solve(i);
    }
	
	
	for(int i=2;i<=n;i++){
		a[i]++;
		ans*=a[i];
		ans%=1000000007;
	}
	cout << ans;
	
	return 0;
}

2.洪水

Description

魔法森林的地图是R行C列的矩形。能通行的空地表示为’.’，C君倾倒洪水的地点标记为’*’，无法通行的巨石阵标记为’X’，海狸的巢穴标记为’D’，而画家和三只小刺猬的初始位置标记为’S’。

每一分钟，画家和三个小刺猬可以走到相邻(上、下、左或右)的四个空地之一。与此同时，洪水每一分钟也会扩大到相邻(上、下、左或右)的所有的空地。一旦空地被淹没，就无法再通行。洪水无法通过巨石阵。但是海狸的巢穴建在很高的地方，永远不会淹没。

注意，画家和三只小刺猬无法进入即将被淹没的空地，即如果他们与洪水在同一分钟到达某个空地，就不能进入。

编写一个程序，给定一个魔法森林的地图，输出为了让画家和三只小刺猬安全地到达海狸的巢穴所需的最短时间。

Input

第1行：2个整数R,C

接下来R行，每行C个字符 (’.’, ‘*’, ‘X’, ‘D’ 或 ‘S’)

地图只含有恰好1个’D’和1个’S’，而’*'可能有零个或多个

Output

1个整数，表示最短的到达狸的巢穴所需的时间。如果无法到达，输出"KAKTUS"

Sample Input 1

3 6
D…*.
.X.X…
…S.

Sample Output 1

6

Sample Input 2

3 3
D.*
…
…S

Sample Output 2

KAKTUS

Sample Input 3

3 3
D.*
…
.S.

Sample Output 3

3
考试时，我一脸懵逼的看着它。所幸，我还有一个数据可骗。。。
回到正题，实际上只要多打几个标记，标记不同事物，就可以了。
开了两个bfs，然后在这次也学到了pair，用它将两个数据合成一个数据。

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

const int maxn=1010;

int n,m;
int a[maxn][maxn];
int sx,sy,xx,yy,xk,yk; 

int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};

bool in(int x, int y)
{
	return 1 <= x&&x<=n&&1 <= y&&y <= m;
}

queue<pair<int , int> > qu;

void bfs1(){
	
//	qu.push(make_pair(xk,yk));
//	a[xk][yk] = 1;
	while(!qu.empty())
	{
		int x = qu.front().first;
		int y = qu.front().second;
		qu.pop();
		
		for(int i=0;i<4;i++){
			int tx = x + dir[i][0];
			int ty = y + dir[i][1];
			
			if(in(tx,ty)&&a[tx][ty] == 0)
			{
				qu.push(make_pair(tx,ty));
				a[tx][ty] = a[x][y] + 1;
			}	 
		}
	}
}

int bfs2(){
//	queue<pair<int , int> > qu;
	qu.push(make_pair(sx,sy));
	a[sx][sy] = -1;
	while(!qu.empty()){
		int x = qu.front().first;
		int y = qu.front().second;
		qu.pop();
		for(int i=0;i<4;i++){
			int tx = x + dir[i][0];
			int ty = y + dir[i][1];
			
			if(tx == xx && ty == yy){
				return abs(a[x][y]);
			}
			
			if(in(tx,ty)&&(a[tx][ty]==0||abs(a[x][y]-1)<a[tx][ty]))
			{
			
				qu.push(make_pair(tx,ty));
				a[tx][ty] = a[x][y] - 1;
			}	 
		}
	}
	return -1;
}
int main(){
	cin >> n >>m;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			char ch;
			cin >> ch;
			if(ch == 'X') a[i][j] = -1;
			if(ch == 'S') sx=i,sy=j;
			if(ch == 'D') {
				xx=i,yy=j; 
				a[i][j]=-1;
			}
			if(ch == '*') {
				qu.push(make_pair(i,j));a[i][j]=1;
			}
		}
	} 
	bfs1();
	int ans = bfs2();
	if(ans==-1){
		cout <<"KAKTUS";
    }else{
    	cout << ans;
	}
	return 0; 
}

3.关押罪犯

Description

S 城现有两座监狱，一共关押着 N名罪犯，编号分别为 1 ~ N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用 “怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为 c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为 c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 S 城 Z 市长那里。公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

在详细考察了 N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。

那么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？

Input

输入第一行为两个正整数 N(1≤N≤20000) 和 M(1≤M≤100000)，分别表示罪犯的数目以及存在仇恨的罪犯对数。

接下来的 M 行每行为三个正整数 aj,bj,cja_j,b_j,c_jaj​,bj​,cj​，表示 aja_jaj​ 号和 bjb_jbj​ 号罪犯之间存在仇恨，其怨气值为 cjc_jcj​。数据保证 1<aj,bj≤N1<a_j, b_j \le N1<aj​,bj​≤N，0<cj≤1090 < c_j \le 10^90<cj​≤109，且每对罪犯组合只出现一次。

Output

输出共一行，为 Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出 0。

Sample Input 1

4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884

Sample Output 1

3512

可能是开始没读懂题意，一直都没想出来。考完老师评讲，才完成的。
最后发现挺简单的，用结构体来做，放入每对犯罪和怨气值，重置cmp函数，排序，实际上跟并查集模板差别不大。

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

const int maxn = 200100;
const int maxm = 100100;
struct node{
	int u,v;
	int s;
}e[maxm];

bool cmp(node a,node b){
	return a.s>b.s;
}

int fa[maxn*2];
int n,m;
void init(){
	for(int i=1;i<=2*n;i++){
		fa[i] = i;
	}
}

int get(int x){
	if(fa[x]!=x) fa[x]=get(fa[x]);
	return fa[x];
}

void merge(int x,int y)
{
    fa[get(x)] = get(y);
}
int main(){
	cin >> n >> m;
		init();
    	for(int i=1;i<=m;i++){
    		cin >> e[i].u >> e[i].v >> e[i].s;
		}
	sort(e+1,e+m+1,cmp);

for(int i=1;i<=m;i++){
	if(get(e[i].u)==get(e[i].v)){
	   
		cout << e[i].s;
		return 0;
	}else{
		merge(e[i].u,e[i].v+n);
		merge(e[i].u+n,e[i].v);
		
    } 
}
	cout << "0";
	return 0;
}