cf 102760

照例来个传送门

Dashboard - 2020 KAIST 10th ICPC Mock Contest (XXI Open Cup. Grand Prix of Korea. Division 2) - Codeforces

最近因为学业原因小咕了一段时间，接下来还会继续咕下去的！

主要是每天想着还有博客没写很焦虑（）

日常更新系列就暂停了，但是训练和cf是不会停止的，水题解啊不归纳整理还是会继续的！

今天训练过5补1，剩下的有空再说

前几天cf还没补，有空一定

B.Bombs In My Deck：给a张牌，里面B个炸弹，c滴血，如果抽到炸弹血量-5且还要继续抽，直到死了或者抽到不是炸弹的牌，求死的概率

签到，就不知道为什么有的b能数样例数错

方法一：1-b/a-(b-1)/(a-1)……

奇技淫巧：1-C(a-d,b-d)/C(a,b) d是被炸死需要的次数

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include <iomanip>
#define me(x,y) memset(x,y,sizeof(x))
#define rep(i,a,b) for(ll i=a;i<=b;i++)
#define rev(i,a,b) for(ll i=b;i>=a;i--)
using namespace std;
typedef long long ll;
const ll N = 2e5 + 7, mod = 1e9 + 7;
ll fac[N], ifac[N];
ll fp(ll x, ll y) {
	ll ans = 1;
	while (y) {
		if (y & 1) ans = ans * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return ans;
}
ll C(ll x, ll y) {//C(x,y)
	ll ans = fac[x];
	ll res = ifac[x - y] * ifac[y] % mod;
	ans = ans * res % mod;
	return ans;
}
void pre() {
	fac[0] = 1;
	for (ll i = 1; i < N; ++i) fac[i] = fac[i - 1] * i % mod;
	ifac[N - 1] = fp(fac[N - 1], mod - 2);
	for (ll i = N - 1; i > 0; --i) ifac[i - 1] = ifac[i] * i % mod;
}
ll qp(ll a, ll k, ll p)
{
	ll res = 1;
	while (k) {
		if (k & 1) res = (ll)res * a % p;
		k >>= 1;
		a = (ll)a * a % p;
	}
	return res;
}
int main()
{
	pre(); 
	double sum;
	long long a,b,c;
	cin>>a>>b>>c;
	if(c%5==0) c=c/5;
	else c=c/5+1;
	long long y=C(a-c,b-c),x=C(a,b) ;
	double x1=x,y1=y;
	sum=y1/x1;
	sum=1-sum;
	if(c>b) cout<<1;
	else
	{
		cout << fixed << setprecision(9) <<sum<< endl;
		//printf("%lld\n",sum);
	}
}

D.Fix Wiring​​​​​​：队友过的

F.Square, Not Rectangle：+1，题意：给N列矩形，高度为Ni，求最大正方形，二分枚举长度，搜索区间最小值

HMock Competition Marketing：六则广告，给定成本，给一个广告的播放序列，求一个广告种类集合，使播放时如果预算够的话就一定要播，不够就不播，求播放次数最大值

队友做法：6则广告一共2^6种方案，枚举

我的做法：按照成本大小排序，将选择从64转换成6种，从一种开始枚举，预处理出每则广告的播出次数，如果现在选择了前k则广告预算够，则这k则广告一定是都能播，得出结果，如果前k则可以，前k+1则不行，循环一遍序列，模拟选了前k+1则后的结果，和选前k则的结果记性比较，得到大的。

#include<bits/stdc++.h>
using namespace std;
struct xd{
	int a;
	int b;
};
xd z[100005];
xd r[100005];
long long y[100005];
long long t[100005];
int cmp(xd a1,xd a2)
{
	return a1.a<a2.a;
}
int main()
{//freopen("in.in","r",stdin);//读入数据生成器造出来的数据
//freopen("baoli.txt","w",stdout);
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=6;i++)
	{
		cin>>z[i].a;
		r[i].a=z[i].a;
		r[i].b=i;
		z[i].b=i;
	}
	for(int i=1;i<=n;i++)
	{
		cin>>y[i];//顺序 
		t[y[i]]++;//个数 
	}
	sort(z+1,z+7,cmp);
	int k=m;
	int ans=0,ans2=0;
	for(int i=1;i<=6;i++)
	{
		if(z[i].a*t[z[i].b]>k)
		{
			for(int j=1;j<=n;j++)
			{
				if(r[y[j]].a<=z[i].a)
				{
					m-=r[y[j]].a;
					ans2++;
				}
				if(m<0) 
				{
					ans2--;
					m+=r[y[j]].a;
				}
			
			}
			break;
		}
		else
		{
			ans+=t[z[i].b];
			k-=z[i].a*t[z[i].b];
		}
	}
	cout<<max(ans,ans2)<<"\n";
}

J.Remote Control:给个序列，代表小车的运动(r就是右走一格，d就是下走一格)，给q个小车的初始位置，求他们最后在哪里

一个个小车模拟肯定是不行的，这时候我们得找出哪些小车是会撞墙的哪些是不会的，假设第i步撞墙了，模拟出初始位置，那一个个模拟肯定是会超时的，我们要想办法利用小车的路径只有在撞墙后受到影响的特点

假设小车a（x,y）第i步（设为L）撞墙了，那么此时小车b（x+1,y）和小车a在第i步后时，我们可以直接更改小车a的坐标为小车b的坐标，原坐标清空

而第i步撞墙可以倒推出初始位置（利用第i-1步撞墙的初始位置）看此点是否有小车，没有就不管了，有的话把坐标改了

最后我们可以得到初始点在不撞墙的情况下x轴和y轴移动的距离，而我们更改后的点的坐标不会撞墙，直接处理可得。

#include<bits/stdc++.h>
#define MAXN 600010
using namespace std;
const int N=300000;

char ss[MAXN];
int qaq[MAXN];
int qwq[MAXN];
map<long long, int>m;
set<int>s[MAXN];

long long get_id(int x, int y){return 1ll * x * (N * 2 + 1) + y;}
int get_x(long long x){return x / (N * 2 + 1);}
int get_y(long long x){return x % (N* 2 + 1);}
void mixx(long long id, long long new_id){
	if(!m[new_id]) m[new_id] = m[id], m[id] = 0;
	else{
		if(s[m[new_id]].size() > s[m[id]].size()){
			s[m[new_id]].insert(s[m[id]].begin(), s[m[id]].end());	
			m[id] = 0;
		}
		else{
			s[m[id]].insert(s[m[new_id]].begin(), s[m[new_id]].end());
			m[new_id] = m[id];
			m[id] = 0;
		}
	}
	return;
}
int main()
{
	long long n,q,x,y,num=0;
	cin>>n;
	cin>>ss;
	cin>>q;
	for(int i=1;i<=q;i++)
	{
		cin>>x>>y;
		x=N+x;
		y=N+y;
		long long id = get_id(x,y);
		if(!m[id])
		{
			m[id] = ++num;
			s[num].insert(i);
		}
		else
		{
			s[m[id]].insert(i);
		}
	}
	int nx=N,ny=N;
	for(int i=0;i<n;i++)
	{
		if(ss[i]=='L') nx++;
		if(ss[i]=='R') nx--; 
		if(ss[i]=='U') ny--; 
		if(ss[i]=='D') ny++;  
		long long id=get_id(nx,ny);
		long long nid;
		if(m[id]!=0)
		{
			if(ss[i] == 'L') nid = get_id(nx + 1, ny);
			if(ss[i] == 'R') nid = get_id(nx - 1, ny);
			if(ss[i] == 'U') nid = get_id(nx, ny - 1);
			if(ss[i] == 'D') nid = get_id(nx, ny + 1); 
			mixx(id, nid);
		}
	}
	for(auto t : m)
	{
		
		set<int>::iterator it;
    	for(it=s[t.second].begin ();it!=s[t.second].end ();it++)
    	{
        qaq[*it]=get_x(t.first)-nx;
		qwq[*it]=get_y(t.first)-ny;
    	}
	 } 
	 for(int i=1;i<=q;i++)
	 {
	 	cout<<qaq[i]<<" "<<qwq[i]<<"\n"; 
	 }
	
 } 

K.Sewing Graph：构造，具体我也没读懂，反正就是同x比y，求一个序列，顺序倒序各输出一遍

#include<bits/stdc++.h>
#define MAXN 10010
using namespace std;
int n;
struct Node{
	int x, y, id;
	
}node[MAXN];
int cmp(Node a,Node b)
{
	if(a.x==b.x) return a.y<b.y;
	else return a.x<b.x;
}
int main(){
	scanf("%d", &n);
	for(int i = 1; i <= n; i++){
		scanf("%d%d", &node[i].x, &node[i].y);
		node[i].id = i;
	}
	sort(node+1,node+n + 1,cmp);
	printf("%d\n", n * 2 - 1);
	for(int i = 1; i <= n; i++){
		printf("%d ", node[i].id);
	}
	for(int i = n - 1; i >= 1; i--){
		printf("%d ", node[i].id);
	}
	puts("");
	return 0;
}