D - Trophy

题目大意

有一个游戏，由$N$个关卡组成。第$i$个关卡由一个数对$(A_i,B_i)$组成。

要通过一个关卡，你必须先花$A_i$的时间看一次介绍。然后，用$B_i$的时间打通这个关卡。若想多次通过同一个关卡，则第一次需要看介绍，后面无需再看（即如果想打通第$i$关$N$次，则所需时间为$A_i+N\times B_i$）。

开始时，只有第一关被解锁。当你每打通一关，其下一关会自动解锁（最后一关除外）。求总共打通$X$关的最少时间（重复通关也算）。

$1\le N\le 2\times 10^5$
$1\le A_i,B_i\le 10^9$
$1\le X\le N$

输入格式

$N~X$
$A_1~B_1$
$\vdots$
$A_N~B_N$

输出格式

输出答案。

样例

略，请自行前往AtCoder查看。

分析

仔细想想会发现，通过的方式都是先不重复通过某一关前所有关卡，再通过这一关一定次数，最终达到正好$X$次。因此，我们利用前缀和，依次枚举每个关卡，最终时间复杂度可达$\mathcal O(n)$。

代码

#include <cstdio>
#define INF 0x7FFFFFFFFFFFFFFFLL
using namespace std;

int main()
{
	int n, x;
	scanf("%d%d", &n, &x);
	if(x < n) n = x;
	long long s = 0LL, ans = INF, cur;
	for(int i=1; i<=n; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		if((cur = (s += a + b) + (long long)(x - i) * b) < ans)
			ans = cur;
	}
	printf("%lld\n", ans);
	return 0;
}

E - Packing Potatoes

题目大意

$10^{100}$个土豆排成一列。它们的重量分别是$W_0,W_1,\dots,W_{N-1},W_0,\dots$，即第$i$个土豆的重量是$W_{i\bmod N}$（$i=0,1,2,\dots$）。

Takahashi会往一个盒子里依次放入每个土豆，当放入的土豆总重量$~\ge X$的时候他会换一个新盒子。

给定$Q$个询问。第$i$个询问：给定整数$K_i$，求第$K_i$个盒子中土豆的个数。

$1\le N,Q\le 2\times 10^5$
$1\le X,W_i\le 10^9$
$1\le K_i\le 10^{12}$

输入格式

$N~Q~X$
$W_0~\dots~W_{N-1}$
$K_1$
$\vdots$
$K_Q$

输出格式

输出$Q$行，第$i$行是第$i$个询问的答案。

样例

略，请自行前往AtCoder查看。

分析

周期问题。

代码

#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

using LL = long long;
int cnt[maxn], ord[maxn], w[maxn << 1];

template <typename T>
inline T read()
{
	char c;
	while((c = getchar()) < '0' || c > '9');
	T res = c ^ 48;
	while((c = getchar()) >= '0' && c <= '9')
		res = (res << T(3)) + (res << T(1)) + (c ^ 48);
	return res;
}

inline void print(int x)
{
	if(x > 9) print(x / 10);
	putchar(x % 10 ^ 48);
}

inline void println(int x)
{
	print(x);
	putchar('\n');
}

int main()
{
	int n = read<int>(), q = read<int>(), x = read<int>();
	LL sum = 0LL;
	for(int i=0; i<n; i++)
		sum += w[i + n] = w[i] = read<int>();
	int fill = x / sum * n;
	for(int i=0; i<n; i++)
		cnt[i] = fill, ord[i] = -1;
	x %= sum;
	for(int i=0, j=0, s=0; i<n; i++)
	{
		if(j < i) j = i, s = 0;
		while(s < x)
		{
			s += w[j];
			j += 1;
		}
		cnt[i] += j - i;
		s -= w[i];
	}
	vector<int> path;
	int loop = -1;
	for(int u=0, k=0; ; k++)
	{
		if(ord[u] != -1)
		{
			loop = k - ord[u];
			break;
		}
		ord[u] = k;
		path.push_back(u);
		(u += cnt[u]) %= n;
	}
	int non_loop = path.size() - loop;
	while(q--)
	{
		LL k = read<LL>();
		println(cnt[path[--k < non_loop? k:
				non_loop + (k - non_loop) % loop]]);
	}
	return 0;
}

F - Main Street

WJ...

G - Triangle

题目大意

给定一张由$N$个点组成的简单无向图$G$和它的邻接矩阵$A$。

什么是邻接矩阵 ？

• 邻接矩阵，顾名思义，即表示图中每两点之间关系的矩阵。
• 如本题中$A_{i,j}$表示$i,j$两点之间是否有边。$A_{i,j}=0$表示无边，$1$表示有边。
• 一般来说，对于任意简单无向图，$A_{i,i}=0$，$A_{i,j}=A_{j,i}$ ($i\ne j$)。

求数对$(i,j,k)$的个数，使得：

• $1\le i<j<k\le N$
• $(i,j,k)$三个点在图中组成一个三角形，即$i,j,k$中任意两点之间有一条连边。

$3\le N\le 3000$

输入格式

$N$
$A_{1,1}A_{1,2}\dots A_{1,N}$
$A_{2,1}A_{2,2}\dots A_{2,N}$
$\vdots$
$A_{N,1}A_{N,2}\dots A_{N,N}$（注意没有空格，如10110）

输出格式

输出一个整数，即符合条件的数对$(i,j,k)$的个数。

样例

略，请自行前往AtCoder查看。

分析

前言

• 个人感觉这题其实是这场比赛中最有意思的题。题目不难，但很具有研究意义。
  这里我将从各个角度分析题目，也期待大家在评论区中分享其他方法。

废话不多说，题解开始！

题目说得太啰嗦，其实不用管什么图论，可以看成是给定$N\times N$的$01$矩阵$A$，求$A_{i,j}=A_{i,k}=A_{j,k}=1$的$(i,j,k)$的个数。

再来看数据范围。$N\le 3000$，则$\mathcal O(N^3)$的朴素算法时间可达到$T(2.7\times 10^{10})$，显然无法通过。

然而，事实并非如此。
在仔细研究后发现，时间限制为$3\mathrm{s}$的题目可以使用复杂度稍高的算法。
但是一般来说，极端情况下超过$T(10^{10})$的算法无法通过。
因此，也许是数据不够强吧，使用如下的优化可以恰好通过（#32949139 $37764\mathrm{KB},2755 \mathrm{ms}$）：

#pragma GCC optimize("Ofast") // -Ofast 预编译优化
#include <cstdio>
#define maxn 3000 // 数组大小设置正好，减少内存占用
using namespace std;

// 题目中正常的邻接矩阵
bool a[maxn][maxn];

// 特殊邻接表存储，减少尝试次数
// 这里不使用vector，会拖慢速度
int G[maxn][maxn], sz[maxn];

inline void print(const long long& x) // 快写-输出优化
{
	if(x > 9LL) print(x / 10);
	putchar(x % 10 ^ 48);
}

int main()
{
	// getchar快读输入优化
	int n = 0; char c;
	while((c = getchar()) != '\n')
		n = (n << 3) + (n << 1) + (c ^ 48);
	for(int i=0; i<n; i++, getchar())
		for(int j=0; j<n; j++)
			if(getchar() == '1' && j > i) // j > i：只存一半，去掉重复
				a[i][j] = 1, G[i][sz[i]++] = j;

	// 注意答案数据类型使用long long
	long long ans = 0LL;
	for(int v=0; v<n; ++v)
		for(int i=0; i<sz[v]; ++i) // 直接调取邻接表，省去不必要判断
		{
			int u = G[v][i];
			for(int j=0; j<sz[u]; ++j)
				if(a[v][G[u][j]])
					ans ++;
		}
	print(ans);
	return 0;
}

当然，这种方法并非每道题都能用，因此还是建议大家继续看正解。

正解还是基于上面的朴素算法，可看作：

• 依次遍历$A_{i,j}=1$的$(i,j)$（$i<j$）
• => 将答案加上$A[i]$和$A[j]$对应位置上都是$1$的位置个数
• 输出答案，除以3（去掉每个重复算的三次）

那么别的地方都没办法，只有第二步可以使用bitset的并集(&)操作进行优化。此时时间复杂度为$\mathcal O(\frac{n^3}w)$，其中$w=64$。详见代码。

代码

#include <cstdio>
#include <bitset>
#define maxn 3000
using namespace std;

bitset<maxn> a[maxn];

int main()
{
	int n = 0; char c;
	while((c = getchar()) != '\n')
		n = (n << 3) + (n << 1) + (c ^ 48);
	for(int i=0; i<n; i++, getchar())
		for(int j=0; j<n; j++)
			if(getchar() == '1')
				a[i].set(j); // a[i][j] = 1
	long long ans = 0LL;
	for(int i=0; i+1<n; i++)
		for(int j=i+1; j<n; j++)
			if(a[i][j])
				ans += (a[i] & a[j]).count(); // 取交集，数1的个数
	printf("%lld\n", ans / 3LL);
	return 0;
}