YUSS Round 1

YUSS Round 1

A. 国庆快乐

签到题。

#include<bits/stdc++.h>

using namespace std;

int main()
{
	printf("Happy 70th Anniversary of People's Republic of China");
	return 0;
}

B. 买彩旗

这道题是一道基本的计算题。不少同学使用float或者double存储钱数，但其实只需要将钱数$\times10$后再除以单价$\times10$（即$46$）即可。（被除数和除数同时乘以一个数，商不变）

#include<bits/stdc++.h>

using namespace std;

int a,b;

int main()
{
	scanf("%d%d",&a,&b);
	printf("%d",(a*10+b)/46);
	return 0;
}

C. 做作业时间

这道题同样也考察了基本的计算。

易知总时间应当是$(c\times60+d)-(a\times60+b)$分钟，那么如何将这个分钟数转化为小时+分钟的形式呢？

我们知道，在带余除法中：被除数$\div$除数$=$商$\cdots$余数。

那么，易知被除数应该是总时间，除数为小时和分钟的进率，$60$。此时，商即为小时数，余数即为分钟数。

在C++中整除运算可直接使用'/'，取模运算可直接使用'%'。

#include<bits/stdc++.h>

using namespace std;

int a,b,c,d;

int main()
{
	scanf("%d%d%d%d",&a,&b,&c,&d);
	printf("%d %d",((c*60+d)-(a*60+b))/60,((c*60+d)-(a*60+b))%60);
	return 0;
}

D. 等比数列

这道题稍有难度，考察了对循环和数学知识的使用。

因为$n\leq30$，所以可以直接用for循环计算；因为$1+2+4+8+\cdots+2^{30}\leq2{31}-1$，所以用int存的下。

但是循环的方式太过复杂。

我们可以推导出：$$\sum_{i=0}^{n}2i=2^{n+1}-1$$

推导过程如下：

令$A=\sum_{i=0}^{n}2i$，

则$2A=\sum_{i=0}^{n}2i\cdot2=\sum_{i=0}^{n}2{i+1}=\sum_{i=1}^{n+1}2i$

所以$A=2A-A=(\sum_{i=1}^{n+1}2i)-(\sum_{i=0}^{n}2i)=2^{n+1}-20=2^{n+1}-1$

由此，我们可以得到这道题更为简略的代码。

在C++中，幂运算可以使用pow函数。使用方法如下：

pow(a,b)

它等价于$a^b$.

#include<bits/stdc++.h>

using namespace std;

int n,sum;

int main()
{
	scanf("%d",&n);
	sum=pow(2,n+1)-1;
	printf("%d",sum);
	return 0;
}

E.排队接水

这道题用到的算法叫做贪心。

小学奥数告诉我们，按接水用时从少到多排队，就能使总等待时间最小。

所以只需要将所有数据读入后从小到大进行排序即可。

答案应为：$$\frac{\sum_{i=1}^{n}T_i(n-i)}{n}(T_1\le T_2\le T_3\le \cdots \le T_n)$$

#include<bits/stdc++.h>

using namespace std;

int n;
double ans;

struct node {
	int num,time;
}p[1001];

bool cmp(node a,node b) {
	if(a.time==b.time) {
		return a.num<b.num;
	}
	else {
		return a.time<b.time;
	}
}

void Read() {
	scanf("%d",&n);
	for(int i=1;i<=n;i++) {
		p[i].num=i;
		scanf("%d",&p[i].time);
	}
}

void Print() {
	sort(p+1,p+n+1,cmp);
	for(int i=1;i<=n;i++) {
		ans+=(n-i)*p[i].time;
	}
	ans/=n;
	printf("%.2lf",ans);
	return;
}

int main()
{
	Read();
	Print();
	return 0;
}

F. 借教室

有个算法叫做二分。

举个例子，你手上有一本书，你要翻到第$x$页，假定你不知道这本书共有多少页，且无法估计这一页在书的几分之几处，那你最快翻到这一页的策略是什么？

很显然，先翻到一半的位置，看页码比你的目标页码是大了还是小了，然后再选取这本书的前（后）一半，再次对半翻……

明白这个策略了吗？如果明白了，那恭喜你，你已经学会二分这种算法了。

但是二分的使用需要一定的前提条件，这个序列必须满足单调性。

但这道题还需要一个叫做差分数列的东西。

很好理解，是吧。那你把这两样东西放一起拼拼凑凑，这道题就可以了。

#include<bits/stdc++.h>
#define N 1000001

using namespace std;

int L,R,mid,n,m;
int r[N],d[N],s[N],t[N],day[N];

bool Judge(int x) {
	memset(day,0,sizeof(day));
    for(int i=1;i<=mid;i++) {
        day[s[i]]+=d[i];
        day[t[i]+1]-=d[i];
    }
    if(day[1]>r[1]) {
    	return true;
	}
    for(int i=2;i<=n;i++) {
        day[i]+=day[i-1];
        if(day[i]>r[i]) {
        	return true;
		}
    }
    return 0;
}

long long lower_bound(int l,int r) {
	while(l<r) {
		mid=(l+r)/2;
		if(Judge(mid)) {
			r=mid;
		}
		else {
			l=mid+1;
		}
	}
	return r;
}

void Read() {
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) {
		scanf("%d",&r[i]);
	}
	for(int i=1;i<=m;i++) {
		scanf("%d%d%d",&d[i],&s[i],&t[i]);
	}
	return;
}

int main()
{
	Read();
	L=1;
	R=m;
	if(m!=lower_bound(L,R)) {
		printf("-1\n%lld",lower_bound(L,R));
	}
	else {
		printf("0");
	}
    return 0;
}

G. 中国高铁

（个人觉得这是题面写得最好的一道题。）

这题考了一个分层图。

简单来说，在未修建任意一条高铁前，你只需关注第$1$层图。

在修建了一条高铁后，你就将上面一张图中的高铁起点与下面一张图的高铁终点相连，边权为原边权的一半。

如此，最多有$k+1$张平行的图。

因为上下平行的各张图都是相同的，所以这并不影响最短路的正确性。

因为题目不要求要把$k$条高铁都修建完，所以取每张图中$dis[n]$的最小值即可。

#include<bits/stdc++.h>
#define N 60
#define M 3010
#define INF 0x3f3f3f3f

using namespace std;

int n,m,k,cnt,ans=INF;
int head[N],dis[N][N];
bool vis[N];

struct node {
	int now,d,num;
	bool operator < (const node& rhs) const {
		return rhs.num<num;
	}
};

struct edge {
	int nxt,to,w;
}e[M];

void addEdge(int u,int v,int w) {
	e[++cnt]=(edge){head[u],v,w};
	head[u]=cnt;
	return;
}

void Read() {
	memset(dis,127,sizeof(dis));
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=m;i++) {
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		addEdge(u,v,w);
		addEdge(v,u,w);
	}
	return;
}

void Dijkstra() {
	priority_queue <node> q;
	dis[1][0]=0;
	q.push((node){0,0,1});
	while(!q.empty()) {
		node t=q.top();
		q.pop();
		for(int i=head[t.num];i;i=e[i].nxt) {
			if(dis[e[i].to][t.now]>t.d+e[i].w) {
				dis[e[i].to][t.now]=t.d+e[i].w;
				q.push((node){t.now,dis[e[i].to][t.now],e[i].to});
			}
			if(t.now+1<=k) {
				if(t.d+e[i].w/2<dis[e[i].to][t.now+1]) {
					dis[e[i].to][t.now+1]=t.d+e[i].w/2;
					q.push((node){t.now+1,dis[e[i].to][t.now+1],e[i].to});
				}
			}
		}
	}
	return;
}

void Print() {
	for(int i=0;i<=k;i++) {
		ans=min(ans,dis[n][i]);
	}
	printf("%d",ans);
	return;
}

int main()
{
	Read();
	Dijkstra();
	Print();
	return 0;
}