Codeforces Round #824 (Div. 2)

A 

Working Week

题意：告诉你一周的长度n，其中有三天是休息日，其中一天固定在第n天，让你选择另外两天在哪，规定：休息日不能相邻。求出最大的

其中l为工作日的长度。

思路： 我们在第2天和第n天定为休息日，然后在中间再确定一个休息日。最优的情况就是尽量构造一个等差数列，找到最大的公差d满足等差数列的前3项和小于等于n-3。前两项构成公差d的等差数列，剩余天数放到第三项，再计算答案即可。

#include <bits/stdc++.h>
#define lowbit(x) x&(-x)
#define ios std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0)
#define PII pair<int,int>
typedef long long ll;
const int N=1e6+10;
const int inf=0x3f3f3f3f;

using namespace std;
/*
(1+1+2d)*3/2>n-3
(2+2d)*3/2
(1+d)*3>n-3
*/
int n;
int a[5];
bool check(int x)
{
	if((1+x)*3<=n-3) return 1;
	else return false;
}
void solve()
{
	cin>>n;
	int l=0,r=n;
	while(r>l)
	{
		int mid=(l+r+1)>>1;
		if(check(mid)) l=mid;
		else r=mid-1;
	}
	a[0]=1,a[1]=1+l,a[2]=n-5-l;
	cout<<min(abs(a[1]-a[0]),min(abs(a[2]-a[1]),abs(a[2]-a[0])))<<'\n';
}
int main()
{
	//ios;
	int _t=1;
	cin>>_t;
	while(_t--) solve();
	system("pause");
	return 0;
}

B

Tea with Tangerines

题意：给定n个数，每次操作可以使一个数x分解成x=y+z，可以对分解后的数继续分解，问最少多少次操作后，任意两数中，较大数不会大于等于较小数的两倍

思路：我们先找到数组中最小的数mi，这个数一定是不需要操作的；将其他数分解成小于2*mi的数即可，也就是比较待分解的数与2*mi-1的关系，若(k+1)*(2*mi-1)>=x>k*(2*mi-1)，那么操作次数为k

#include <bits/stdc++.h>
#define lowbit(x) x &(-x)
#define ios                           \
	std::ios::sync_with_stdio(false); \
	cin.tie(0), cout.tie(0)
#define PII pair<int, int>
typedef long long ll;
const int N = 110;
const int inf = 0x3f3f3f3f;

using namespace std;
int n;
int a[N];
void solve()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> a[i];
	sort(a + 1, a + n + 1);
	ll ans = 0;
	for (int i = 2; i <= n; i++)
	{
		ans+=((int)ceil(1.0*a[i]/(2*a[1]-1))-1);
	}
	cout << ans << '\n';
}
int main()
{
	// ios;
	int _t = 1;
	cin >> _t;
	while (_t--)
		solve();
	system("pause");
	return 0;
}

C

Phase Shift

题意：给定字符串，让你求出映射后字典序最小的字符串，映射规则需满足长度为26的环。

思路：贪心，从左到右遍历字符串，若当前字符还没有制定映射规则，我们就将其映射到可以映射范围内最小的字符。

假设当前字符x还没映射规则 ，假设还没有字符映射到a，那么理论上我们是可以将x映射到a的，但若存在a->...->x，但若这条链的长度不是26，我们是不能将x映射到a的，否则会形成一个闭环，无法将剩余字符加入环中。

#include <bits/stdc++.h>
#define lowbit(x) x&(-x)
#define ios std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0)
#define PII pair<int,int>
typedef long long ll;
const int N=1e6+10;
const int inf=0x3f3f3f3f;

using namespace std;
int n;
string s;
void solve()
{
	cin>>n;
	cin>>s;
	map<char,char>mp,mmp;
	for(int i=0;i<n;i++)
	{
		if(mp[s[i]]) continue;
		else
		{
			for(char t='a';t<='z';t++)
			{
				if(s[i]==t) continue;
				if(!mmp[t])//没有字母映射到t
				{
					int cnt=1;
					char tem=t;
					while(tem!=s[i]&&mp[tem])
					{
						tem=mp[tem];
						cnt++;
					}
					if(tem==s[i]&&cnt<26) continue;
					mp[s[i]]=t;
					mmp[t]=s[i];
					break;
				}
			}
		}
	}
	for(int i=0;i<n;i++) cout<<mp[s[i]];
	cout<<'\n';
}
int main()
{
	//ios;
	int _t=1;
	cin>>_t;
	while(_t--) solve();
	system("pause");
	return 0;
}

D

Meta-set

题意：给定n张卡牌，每张卡片有k种属性，每种属性取值0,1,2，三张卡片为一组，5张卡片为一个集合，一组称为good当且仅当这三张牌的每一种属性要么全相等，要么全不同。问满足集合至少含有2组good的集合数。

思路：先考虑什么样的集合满足至少含有2组good，我们发现当两个good组含有一个共同的牌时，这些牌组成的集合就是满足题意的。 没有共同牌的两组，一定不能组成满足题意的集合。因为任意两张牌可以唯一确定第三张牌。题目转化成每张卡牌所在good组的数量。我们用三进制来储存当前牌的属性。两重for循环遍历任意两张卡片来求第三张卡片是否出现过即可，如果出现过就直接将3张卡片的贡献度都加1，但是这样会重复计算，也就是说比如第1，2，3张卡片可以合成一个good组，那么我们在枚举(1,2),(1,3),(2,3)时，这三张牌的贡献都会计算一次，所以我们需要将每张牌的贡献除以3得到不重复的贡献。最后我们遍历所有牌所在good组的数量t，对于包含某张卡片的任意两个组都可以组成一个good的集合，对答案的贡献为C(t,2)。

#include <bits/stdc++.h>
#define lowbit(x) x&(-x)
#define ios std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0)
#define PII pair<int,int>
typedef long long ll;
const int N=1e3+10;
const int inf=0x3f3f3f3f;

using namespace std;
int n,k;
int a[N][25];
map<ll,bool>st;
map<ll,int>ans;
ll cal(int r)
{
	ll ret=0;
	for(int i=1;i<=k;i++)
	{
		ret=ret*3+a[r][i];
	}
	return ret;
}
void solve()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=k;j++)
			cin>>a[i][j];
		st[cal(i)]=1;
	}
	for(int i=1;i<=n;i++)
	{
		ll s1=cal(i);
		for(int j=i+1;j<=n;j++)
		{
			ll s2=cal(j);
			ll tem=0;
			for(int l=1;l<=k;l++)
			{
				if(a[i][l]==a[j][l])
				{
					tem=tem*3+a[i][l];
				}
				else
				{
					tem=tem*3+(3^a[i][l]^a[j][l]);
				}
			}
			if(st[tem])
			{
				ans[s1]++;
				ans[s2]++;
				ans[tem]++;
			}
		}
	}
	ll ret=0;
	for(int i=1;i<=n;i++)
	{
		ll s=cal(i);
		if(ans[s])
		{
			ans[s]/=3;
			ret+=(ans[s]*(ans[s]-1))/2;
		}
	}
	cout<<ret<<'\n';
}
int main()
{
	//ios;
	int _t=1;
	//cin>>_t;
	while(_t--) solve();
	system("pause");
	return 0;
}