Unable to find root device /dev/...

后来还是去 Arch Linux 论坛上找，才找到解决方案。大概的思路，是要用 Arch Linux 安装光盘启动，然后 chroot 到硬盘上的系统，再更新 udev, mkinitcpio 之类的东西，才能再次启动。

首先从 Arch Linux 的官方网站上下载 Arch Linux 镜像，我选择的不是网络安装版，不知道网络安装版能不能用，没试过。由于是在学校机房下载的，我选择了教育网镜像。

我是打算用 U 盘启动的，学校机房的电脑又是 Windows, 所以就下载了一个 Cygwin, 使用 dd 把镜像刷到 U 盘里：

~ # dd if=archlinux.iso of=/dev/sdb

如果不能确定 U 盘是哪个设备，可以用如下命令查看有什么分区（似乎 fdisk -l 在 Cygwin 下没用）：

~ # cat /proc/partitions

在那台电脑上启动 U 盘的 Arch Linux 系统，然后用 fdisk -l 查到你原来装有 Arch Linux 硬盘是哪个设备（本文假设是 /dev/sda1）：

/ # mkdir /mnt/arch
/ # mount /dev/sda1 /mnt/arch
/ # cd /mnt/arch
/mnt/arch # mount -t proc proc proc/
/mnt/arch # mount -t sysfs sys sys/
/mnt/arch # mount -o bind /dev dev/

如果你的启动分区不是独立分区，那么下面这个步骤不用做。我的启动分区是 /dev/sda2, 要将其挂载到 boot/ 上：

/mnt/arch # mount /dev/sda2 boot/

然后开始 chroot 到当前目录（/mnt/arch）：

/mnt/arch # chroot . /bin/bash
/ # source /etc/profile

之后的步骤需要连接到网络。我是直接连在路由器上，就开 DHCP 客户端就可以了，其它的上网方式需要其它的设置。

/ # dhcpcd eth0

然后，最重要的步骤来了，重装 udev 然后重建镜像：

/ # pacman -Syy
/ # pacman -Syu
/ # pacman -S udev
/ # pacman -S mkinitcpio
/ # mkinitcpio -p linux
/ # reboot

重启之后一般可以看到久违的的画面了。这个时候我是重装了所有的软件包，这样一些其它的错误也修复了：

/ # comm -23 <(pacman -Qeq) <(pacman -Qmq) | pacman -S -
/ # comm -23 <(pacman -Qdq) <(pacman -Qmq) | pacman -S --asdeps -

一开始我理解错题意了，我当时以为是只要那个串含有回文子串，那么就把它算进去。其实我感觉还是挺傻的，因为长度为 1 的串也是回文串啊，那这样岂不是所有的都要算进去了？

这样的话问题就简单多了。首先考虑当 k > n 时，由于此时长度为 n 的串中，长度为 k 的子串是不存在的。可以这么说，这个子串的集合是空集。那么，我说 ∅ 中的任何一个元素，都是回文串，这是没有问题的吧。如果你觉得有问题，那你找一个不是回文串的元素出来看看呀？

（以下段落的存在是为了说明“空集中的任何一个元素都是回文串”。）

其实上面那种情况是一个逻辑问题，有的时候用代码来解释一些现象还是比较方便的。打个比方，0 的阶乘大家都知道应该是 1 吧，为什么是 1 呢？看代码：

int frac(int n)
{
	int r = 1;
	for (int i = 1; i <= n; ++i)
		r *= i;
	return r;
}

这是计算阶乘的代码，如果将 0 传给参数 n, 那么返回的值应该是 1.

好，那么如果有一个函数，可以判断集合 s 中，是不是每个元素都是回文串。那么代码应该这么写：

bool is_palindrome(const string &n)
{
	return whether_n_is_a_palindrome_string;
}
bool are_all_palindromes(const set<string> &s)
{
	set<string>::iterator it;
	for (it = s.begin(); it != s.end(); ++it)
		if (!is_palindrome(*it))
			return false;
	return true;
}

如果给 are_all_palindromes 的参数 s 传入的是空集，那么，上面的函数会返回 true. 所以，k > n 的时候，任何一个长度为 n 的串的长度为 k 的子串都是回文串。

（说明完毕。）

其它情况，当 k < n 的时候：如果 k 是偶数，那么那些所有元素都是一样的串才能符合要求；如果 k 是奇数但不是 1, 那么那些只有两种元素的串才能符合要求；如果 k 是 1 那么所有的串都符合要求。所以代码如下：

#include <iostream>
using namespace std;
inline int power(int a, int n)
{
	long long result = 1;
	while (n--)
		result = (result * a) % 1000000007;
	return result;
}
int main()
{
	int n, m, k;
	cin >> n >> m >> k;
	if (k == 1 || k > n)
		cout << power(m, n) << endl;
	else if (k == n)
		cout << power(m, (n + 1) >> 1) << endl;
	else if (k & 1) // k is odd.
		cout << m * m << endl;
	else // k is even.
		cout << m << endl;
	return 0;
}

250 分的题，题意是，皮卡丘只会说三个音节：“pi”、“ka”、“chu”；给出一个只有小写字母的字符串，判断皮卡丘能不能说出这样的话。比如，“pikachu”、“pikapika”之类的要输出“YES”，反之输出“NO”。

我的办法比较笨，都是逐个字母来判断的。但是我感觉这种方法比较快，是 O(n) 的算法。在 Challenge 的时候看到一种方法，每次判断开头几个字母是不是“pi”、“ka”、“chu”，如果不是就直接返回“NO”了，如果是的话，就删除前面几个字母。但是这种方法似乎没法通过系统测试，不过在 Challenge 阶段这样的题解也没人敢动，所以这样错的原因可能是效率比较低。

#include <string>
using namespace std;
class PikachuEasy
{
public:
	string check(string word)
	{
		int i;
		for (i = 0; i < word.length(); ++i)
		{
			if (word[i] == 'p')
			{
				if (++i >= word.length())
					return "NO";
				if (word[i] != 'i')
					return "NO";
			}
			else if (word[i] == 'k')
			{
				if (++i >= word.length())
					return "NO";
				if (word[i] != 'a')
					return "NO";
			}
			else if (word[i] == 'c')
			{
				if (++i >= word.length())
					return "NO";
				if (word[i] != 'h')
					return "NO";
				if (++i >= word.length())
					return "NO";
				if (word[i] != 'u')
					return "NO";
			}
			else
				return "NO";
		}
		return "YES";
	}
};

500 分的题目，题意是，有 n 个数字，每次可以删除其中“不是首位的”数字，然后获得那个被删除数字左右两个数字之乘积的能量。这些数字都是正的。数据范围是 3 ≤ n ≤ 10, 那这样的话即使用穷举也是最多 8! = 40320, 这就无压力了。

#include <vector>
#include <algorithm>
using namespace std;
class CasketOfStarEasy
{
public:
	int maxEnergy(vector<int> weight)
	{
		return maxEnergyRecursive(weight);
	}
	int maxEnergyRecursive(const vector<int> &weight)
	{
		if (weight.size() == 3)
			return weight[0] * weight[2];
		int result, max_result = 0;
		for (int i = 1; i < weight.size() - 1; ++i)
		{
			vector<int> clone = weight;
			clone.erase(clone.begin() + i);
			result = maxEnergy(clone) + weight[i - 1] * weight[i + 1];
			max_result = max(max_result, result);
		}
		return max_result;
	}
};

1000 分的题目，不会做。和室友讨论了将近 40 分钟，没有什么结果。

然后 Challenge 阶段，居然意外地搞了两份代码。今天早上起床的时候，发现 Rating 涨了，终于变成了绿人……

A 题 151A Soft Drinking 的背景是几个好朋友在一起喝饮料。其问题的实质是这样的：要制造一种物品，需要不同数量的不同原料；给出各种原料的数量和每件物品需要每种原料各多少，然后求最多能制造多少个这种物品。

#include <climits>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
	int n, k, l, c, d, p, nl, np, r = INT_MAX;
	cin >> n >> k >> l >> c >> d >> p >> nl >> np;
	r = min(r, k * l / nl);
	r = min(r, c * d);
	r = min(r, p / np);
	cout << r / n << endl;
	return 0;
}

B 题 151B Phone Numbers 的背景是几个好朋友的电话本。某市的电话是 6 位数，都是以 22-22-22 这样的形式给出。有三种类型的电话，一种是计程车电话，其特点是电话每个数字都相同；一种是披萨外卖电话，其特点是几个数字是递减的；其余的是妹子的电话。最后问，拥有计程车的电话、披萨外卖电话和妹子的电话最多的人分别是谁。

后来看到别人的博客，里面说 B 题如果没有人有某种类型的电话，那么这个时候要把所有人的名字输出。但是我的代码里没有考虑这种情况，似乎这样也 AC 了。

#include <cstdio>
#include <string>
#include <vector>
#include <cctype>
#include <iostream>
using namespace std;
inline bool is_taxi(const string &str)
{
	char first = str[0];
	for (int i = 0; i < str.size(); ++i)
		if (isdigit(str[i]))
			if (str[i] != first)
				return false;
	return true;
}
inline bool is_pizza(const string &str)
{
	char previous = str[0];
	for (int i = 1; i < str.size(); ++i)
		if (isdigit(str[i]))
			if (str[i] >= previous)
				return false;
			else
				previous = str[i];
	return true;
}
inline int phone_type(const string &str)
{
	if (is_taxi(str))
		return 0;
	if (is_pizza(str))
		return 1;
	return 2;
}
const char OUTPUT_FORMAT[3][128] = {
	"If you want to call a taxi, you should call: ",
	"If you want to order a pizza, you should call: ",
	"If you want to go to a cafe with a wonderful girl, you should call: "
};
int best_count[3] = {0};
vector<string> best_names[3];
int main()
{
	// freopen("input.txt", "r", stdin);
	int n; cin >> n;
	while (n--)
	{
		int s, cnt[3] = {0};
		string name, phone;
		cin >> s >> name;
		while (s--)
		{
			cin >> phone;
			++cnt[phone_type(phone)];
		}
		for (int i = 0; i < 3; ++i)
		{
			if (cnt[i] > best_count[i])
			{
				best_count[i] = cnt[i];
				best_names[i].clear();
				best_names[i].push_back(name);
			}
			else if (cnt[i] == best_count[i])
			{
				best_names[i].push_back(name);
			}
		}
	}
	for (int i = 0; i < 3; ++i)
	{
		cout << OUTPUT_FORMAT[i];
		if (!best_names[i].empty())
		{
			cout << best_names[i][0];
			for (int j = 1; j < best_names[i].size(); ++j)
				cout << ", " << best_names[i][j];
		}
		cout << "." << endl;
	}
	return 0;
}

C 题 150A Win or Freeze 说的是两个人玩游戏，一开始 1 号玩家面临一个数 p, 如果他能写出 p 的一个非平凡因数 q, 就可以轮到玩家 2, 让他写出 q 的非平凡因数 r, … 直到某个玩家不能写为止，然后那个不能继续写数的玩家获胜。输入数据给出数 p, 问哪个玩家能获胜；如果 1 号玩家获胜，第二行要输出 1 号玩家应该写的数字是什么。如果 1 号玩家一开始就赢了，那么就在第二行输出 0.

这题一开始我的想法是，如果一个数是质数或者 1, 那么 1 号玩家就没法写数了，他就直接赢了。如果开始的数是两个质数的乘积，那么 1 号玩家只能写其中一个质因数，那 2 号玩家就赢了。如果是 > 2 个质因数，那 1 号玩家可以找出其中两个质因数，相乘，写出那个数给 2 号玩家，这样 2 号玩家只能写一个质数，然后 1 号就赢了。

这题的数据范围比较大，当时我居然想到用 Miller-Rabin 算法。开始的时候 pretest 7 总是过不了，赛后发现那个数据是 445538663413, 是一个比较大的质数，似乎让 Miller-Rabin 判断了几次都没判断出来，比赛时我也没发现，后来用一些小 trick 也算解决了这个问题（只是不能一开始就判断出是不是素数，浪费了一些时间罢了，算法看起来似乎还是对的）。后来赛后的 test 28 把我这题 WA 了，数据是 9999926826034, 这是 2 和一个 4999963413017 的乘积，似乎后者是质数，然后 Miller-Rabin 也把它判错了。

其实这题根本不用这么复杂的方法，直接试除就可以了，管你质数不质数的，找到两个约数，发现原数除完它们后不是 1, 玩家 1 就赢了；反之若是 1 就玩家 2 赢。如果找到 [latex]\sqrt{p}[/latex] 还是没有约数，那 p 就是质数了，还是玩家 1 赢。

#include <iostream>
using namespace std;
typedef long long ll;
int main()
{
	int cnt = 0;
	ll p, d[2];
	cin >> p;
	for (ll i = 2; i * i <= p; ++i)
	{
		while (p % i == 0)
		{
			p /= i;
			d[cnt] = i;
			if (++cnt >= 2)
				goto out;
		}
	}
out:
	if (cnt == 0)
		cout << 1 << endl << 0 << endl;
	else if (p == 1 || cnt == 1)
		cout << 2 << endl;
	else
		cout << 1 << endl << d[0] * d[1] << endl;
	return 0;
}

D 和 E 到时候再研究一下吧，要加油啊。

2012 年 2 月 19 日更新：D 题 150B Quantity of Strings 的题解请点击这里。

似乎这道题原题标题犯了个小小的语法错误……

关于这道题的解法，Greenmoon55 说，可以用 vector + sort + unique 系列的方法解决这个问题，还提到 set 可能会超时超内存^[GRN'11]。我想原因是插入删除过程其实是 O(logn) 的，并且使用动态内存分配频繁，各种冗余数据比较多吧。这种方法的时间复杂度是 O(n²logn).

我的解法是另一种，我使用一个数组 planes[3][N][N], 记录输入的每一条直线。在每执行一条直线的命令的时候，判断某一个方块是否已经被其它直线去掉了。所以这就降了一维，复杂度是 O(n²). 但是现场赛时，我可能会采取 Greenmoon55 的做法。

源代码

#include <cstdio>
#include <cstring>
using namespace std;
const int N = 1001;
bool planes[3][N][N];
int n, m;
inline bool is_coord_valid(int x, int y)
{
	if (x >= 1 && x <= n && y >= 0 && y <= n)
		return true;
	return false;
}
inline int count_cubes(int i0, int x, int y)
{
	int i1 = (i0 + 1) % 3, i2 = (i0 + 2) % 3;
	if (planes[i0][x][y])
		return 0; // Already counted.
	planes[i0][x][y] = true;
	int result = 0;
	for (int z = 1; z <= n; ++z)
		if (!planes[i1][y][z] && !planes[i2][z][x])
			++result;
	return result;
}
int main()
{
	int T, x, y, r; char a, b, buf[32];
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d %d", &n, &m); r = 0;
		memset(planes, false, sizeof planes);
		for (int i = 0; i < m; ++i)
		{
			gets(buf); // Skip EOLN.
			scanf("%c=%d,%c=%d", &a, &x, &b, &y);
			if (a == 'X' && b == 'Y') r += count_cubes(0, x, y);
			else if (a == 'Y' && b == 'X') r += count_cubes(0, y, x);
			else if (a == 'Y' && b == 'Z') r += count_cubes(1, x, y);
			else if (a == 'Z' && b == 'Y') r += count_cubes(1, y, x);
			else if (a == 'Z' && b == 'X') r += count_cubes(2, x, y);
			else if (a == 'X' && b == 'Z') r += count_cubes(2, y, x);
		}
		printf("%d\n", r);
	}
	return 0;
}

参考

• [GRN'11] Greenmoon55:《HDU3682 To Be an Dream Architect》

思路是把每行的学生的列坐标分别排序，枚举左边一列的列号即可。

代码如下：

#include <cmath>
#include <cstdio>
#include <climits>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 222;
int i2j[N][N], cnt[N], n, m, n2;
int main()
{
	// freopen("input.txt", "r", stdin);
	while (cin >> n >> m)
	{
		if (n == 0 && m == 0)
			break;
		memset(cnt, 0, sizeof cnt);
		n2 = n * n;
		for (int i = 0; i < n2; ++i)
		{
			int k, a; cin >> k; --k;
			cin >> a; --a; i2j[k][cnt[k]++] = a;
		}
		for (int i = 0; i < n; ++i)
			sort(i2j[i], i2j[i] + n);
		int rmost = m - n, sum, result = INT_MAX;
		for (int i = 0; i <= rmost; ++i)
		{
			sum = 0;
			for (int j = 0; j < n; ++j)
				for (int k = 0; k < n; ++k)
					sum += abs(i2j[j][k] - (i + k));
			result = min(result, sum);
		}
		cout << result << endl;
	}
	return 0;
}

怎么说呢，这道题纠结了几天，网上没有题解，只有模糊地提到容斥原理。在昨晚出去逛街的时候想到了二维的情况，如果长方形的大小是 A × B 的话，如果 A 和 B 互质，那么可以看出来，对角线穿过了 A + B – 1 个小正方形。如果 A 和 B 不互质，就求最大公约数 G, 令 A’ = A / G, B’ = B / G, 这么说在对角线上有 G 个 A’ × B’ 的长方形，对角线穿过了 (A’ + B’ – 1) × G 个小正方形。

推广到三维的时候就搞错了，当时想到的是，把能够从面 A 看到的小正方形的集合记为 A, 从面 B 和面 C 看到的也记为相应字母，然后能够同时从面 A 和面 B 看到的小正方形集合记为 A∩B, 类似。这样就有容斥原理了：

card(A∪B∪C) = card(A) + card(B) + card(C) – card(A∩B) – card(B∩C) – card(C∩A) + card(A∩B∩C).

在计算 card(A) 之类的东西的时候，可以用二维的方法。但是在计算 card(A∩B) 之类的时候，我一开始用的是 min(card(A), card(B)), 但是后来举出了反例，所以这种方法最后还是错了。

最后实在忍不住了，我就想应该问问当年区域赛 AC 过这题的前辈们。在看到的几份 Regional 总结中，我发现大家都说这题和当年该赛区热身赛里的一题非常像，当时的情景是几乎所有队都是齐刷刷地 AC 了这题。所以我想这也可能是这题题解较少的原因，因为当年可能大家都把它当成水题看待了……

凌晨一点多的时候在 watashi 大牛的博客留言请教，没想到十多分钟就有了解答，感激涕零……

这种思路还是需要一定的空间想象力，方法其实就是之前二维做法的推广，证明起来有点难，不过反正我是信了……

#include <cstdio>
#include <algorithm>
using namespace std;
template <typename T> T gcd(T a, T b)
{
	T r;
	while (b > 0) {
		r = a % b; a = b; b = r;
	}
	return a;
}
template <typename T> T gcd(T a, T b, T c)
{
	return gcd(a, gcd(b, c));
}
int main()
{
	int a, b, c, r;
	while (scanf("%d %d %d", &a, &b, &c))
	{
		if (a == 0 && b == 0 && c == 0)
			break;
		r = a + b + c - gcd(a, b) - gcd(b, c) - gcd(c, a) + gcd(a, b, c);
		printf("%d\n", r);
	}
	return 0;
}

至于三种变换的矩阵，这里就不细说了，移动和缩放其实还是比较简单，旋转比较复杂，维基百科里有介绍。

这次在上面栽了两次，原因是 repeat 时我判断如果是 0 就直接返回了单位矩阵，而没有读到下一个 end 命令。后来为了改得方便，也没有在一开始特判 0, 所以遇到 0 的时候还是会“白算”比较多东西。不过有句话说，要避免不成熟的优化，呵呵……

代码如下：

#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
const double pi = acos(-1.0);
template <int M, int N>
struct matrix
{
	double w[M][N];
	inline double &operator()(int i, int j)
	{
		return w[i][j];
	}
	inline const double &operator()(int i, int j) const
	{
		return w[i][j];
	}
	template <int R>
	inline matrix<M, R> operator*(const matrix<N, R> &b) const
	{
		matrix<M, R> r;
		memset(&r, 0, sizeof r);
		for (int i = 0; i < M; ++i)
			for (int j = 0; j < R; ++j)
				for (int k = 0; k < N; ++k)
					r(i, j) += w[i][k] * b(k, j);
		return r;
	}
};
template <int N>
inline matrix<N, N> identity()
{
	matrix<N, N> r;
	memset(&r, 0, sizeof r);
	for (int i = 0; i < N; ++i)
		r(i, i) = 1.0;
	return r;
}
inline matrix<4, 1> vector3(double x, double y, double z)
{
	matrix<4, 1> r;
	memset(&r, 0, sizeof r);
	r(0, 0) = x; r(1, 0) = y; r(2, 0) = z; r(3, 0) = 1.0;
	return r;
}
inline matrix<4, 4> translate3(double x, double y, double z)
{
	matrix<4, 4> r;
	memset(&r, 0, sizeof r);
	r(0, 0) = 1.0; r(1, 1) = 1.0; r(2, 2) = 1.0;
	r(0, 3) = x; r(1, 3) = y; r(2, 3) = z; r(3, 3) = 1.0;
	return r;
}
inline matrix<4, 4> scale3(double x, double y, double z)
{
	matrix<4, 4> r;
	memset(&r, 0, sizeof r);
	r(0, 0) = x; r(1, 1) = y; r(2, 2) = z; r(3, 3) = 1.0;
	return r;
}
inline void normalize(double &x, double &y, double &z)
{
	double below = sqrt(x * x + y * y + z * z);
	x /= below; y /= below; z /= below;
}
inline matrix<4, 4> rotate3(double x, double y, double z, double a)
{
	matrix<4, 4> r; normalize(x, y, z);
	double cosa = cos(a), mcsa = 1.0 - cosa, sina = sin(a);
	double xy = x * y, yz = y * z, zx = z * x;
	double x2 = x * x, y2 = y * y, z2 = z * z;
	double xsna = x * sina, ysna = y * sina, zsna = z * sina;
	r(0, 0) = cosa + mcsa * x2; r(0, 1) = mcsa * xy - zsna;
	r(0, 2) = mcsa * zx + ysna; r(0, 3) = 0.0;
	r(1, 0) = mcsa * xy + zsna; r(1, 1) = cosa + mcsa * y2;
	r(1, 2) = mcsa * yz - xsna; r(1, 3) = 0.0;
	r(2, 0) = mcsa * zx - ysna; r(2, 1) = mcsa * yz + xsna;
	r(2, 2) = cosa + mcsa * z2; r(2, 3) = 0.0;
	r(3, 0) = 0.0; r(3, 1) = 0.0; r(3, 2) = 0.0; r(3, 3) = 1.0;
	return r;
}
template <int N> // Assumes t > 1.
inline matrix<N, N> self_multiply(const matrix<N, N> &a, int t)
{
	matrix<N, N> r = a;
	int u = t, n = 0, i;
	while (u >>= 1) ++n;
	for (i = n - 1; i >= 0; --i)
	{
		r = r * r;
		if ((t >> i) & 1)
			r = r * a;
	}
	return r;
}
char buffer[64];
double px, py, pz, pa;
int pt;
matrix<4, 4> repeat(int t)
{
	matrix<4, 4> r = identity<4>();
	while (scanf("%s", buffer))
	{
		if (!strcmp(buffer, "end"))
			break;
		else if (!strcmp(buffer, "translate"))
		{
			scanf("%lf %lf %lf", &px, &py, &pz);
			r = translate3(px, py, pz) * r;
		}
		else if (!strcmp(buffer, "scale"))
		{
			scanf("%lf %lf %lf", &px, &py, &pz);
			r = scale3(px, py, pz) * r;
		}
		else if (!strcmp(buffer, "rotate"))
		{
			scanf("%lf %lf %lf %lf", &px, &py, &pz, &pa);
			r = rotate3(px, py, pz, pa / 180.0 * pi) * r;
		}
		else if (!strcmp(buffer, "repeat"))
		{
			scanf("%d", &pt);
			r = repeat(pt) * r;
		}
	}
	if (t <= 0)
		return identity<4>();
	if (t > 1)
		return self_multiply<4>(r, t);
	return r;
}
inline void preprocess(double &a)
{
	static char buf[32];
	sprintf(buf, "%0.2lf", a);
	if (!strcmp(buf, "-0.00")) a = 0.0;
}
inline void print_vector3(const matrix<4, 1> &v)
{
	double x = v(0, 0), y = v(1, 0), z = v(2, 0);
	preprocess(x); preprocess(y); preprocess(z);
	printf("%0.2lf %0.2lf %0.2lf", x, y, z);
}
inline void calculate(const matrix<4, 4> &m, int n)
{
	while (n--)
	{
		scanf("%lf %lf %lf", &px, &py, &pz);
		print_vector3(m * vector3(px, py, pz));
		printf("\n");
	}
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int n;
	while (scanf("%d", &n))
	{
		if (n == 0)
			break;
		calculate(repeat(1), n);
		printf("\n");
	}
	return 0;
}

我的思路是，用两个优先队列，一个是正在下载的文件的队列，另一个是等待下载的文件的队列。对于正在下载的文件队列，维护“所剩字节数最少的那个文件”在堆顶；对于等待下载的文件的队列，维护题目中所描述的那种最优先被下载的文件在堆顶。

然后循环，看正在下载的文件队列是否满，未满则将等待被下载的文件队列中的文件一个个弹出又插入到正在下载的队列。再看那个所剩字节最少的文件，让每个文件都减掉那么多字节，然后把那些字节为 0（即下载完了的）文件删掉，再把所需时间加到计数器。最后循环啊循环就好了。

这道题有一个阴险的地方是：

Print a blank line after the output of each test case.

害我 WA 了两次……

#include <queue>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
struct file
{
	double size, progress, remain;
	inline file(double sz, double pg) : size(sz), progress(pg)
	{
		remain = size - size * progress / 100.0;
	}
	inline bool operator<=(const file &b) const
	{
		if (size == b.size)
			return progress >= b.progress;
		return size <= b.size;
	}
};
class download_priority {
public:
	inline bool operator()(const file &a, const file &b) {
		return b <= a;
	}
};
class remaining_size {
public:
	inline bool operator()(const file &a, const file &b) {
		return a.remain >= b.remain;
	}
};
int file_count, max_download; double bandwidth;
vector<file> download_slot;
priority_queue<file, vector<file>, download_priority> download_queue;
inline void fill_download_slot()
{
	while (download_slot.size() < max_download && !download_queue.empty())
	{
		download_slot.push_back(download_queue.top()); download_queue.pop();
		push_heap(download_slot.begin(), download_slot.end(), remaining_size());
	}
}
inline void decrease_remain_by(double size)
{
	for (int i = 0; i < download_slot.size(); ++i)
		download_slot[i].remain -= size;
}
inline void remove_downloaded_files()
{
	while (!download_slot.empty() && download_slot[0].remain <= 0.0)
	{
		pop_heap(download_slot.begin(), download_slot.end(), remaining_size());
		download_slot.pop_back();
	}
}
inline double download_time()
{
	double second = 0.0;
	while (!download_slot.empty() || !download_queue.empty())
	{
		fill_download_slot();
		double bandwidth_each = bandwidth / (double)download_slot.size();
		// File with least download-time will be download_slot[0].
		double remain_size = download_slot[0].remain;
		double remain_time = remain_size / bandwidth_each;
		decrease_remain_by(remain_size);
		remove_downloaded_files();
		second += remain_time;
	}
	return second;
}
inline bool init_and_input()
{
	scanf("%d %d %lf", &file_count, &max_download, &bandwidth);
	if (file_count == 0.0 && max_download == 0.0 && bandwidth == 0.0)
		return false;
	for (int i = 0; i < file_count; ++i)
	{
		double size, progress;
		scanf("%lf %lf", &size, &progress);
		download_queue.push(file(size, progress));
	}
	return true;
}
int main()
{
	// freopen("input.txt", "r", stdin);
	int i = 0;
	while (init_and_input())
		printf("Case %d: %0.2lf\n\n", ++i, download_time());
	return 0;
}

由于极端情况下，节点数会达到 10⁵, 路径长度会达到 10⁶, 这已经明显超过 32 位整型了。所以需要用 long long. 需要注意的地方就是，如果两个 int 相乘，其结果可能会达到 long long 的话，那么先把两个 int 分别转换成 long long 再乘。至于为什么就不多解释了。

还有极端情况，比如整棵树退化成了链，100,000 个节点要是深搜的话，就 stack overflow 了。所以需要用栈模拟递归。但是我记得我们队的 WH 在某次练习的时候，用深搜成功解决了这个问题，这有两个方面的原因：一个是他的 dfs 函数没有返回值，并且只有一个参数；二是他是从中间那个顶点开始进行深搜的。所以，他骗分导论学得不错啊。

这道题我 WA 了几次，有因为数组开小了，有因为没有使用栈模拟递归的，还有因为没看清到底是应该使用 %lld 还是 %I64d 的。所以以后一定要吸取教训。

还有就是这道题我写了一个数据生成器，树结构的数据生成器还是比较麻烦。

本题源代码

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
const int N = 222222;
const int M = N << 1;
struct glist
{
	int n, m, fe[N], ne[M], he[M], ev[M];
	inline void reset(int sz = 0)
	{
		memset(fe, -1, sizeof fe);
		n = sz; m = 0;
	}
	inline void insert_directed(int u, int v, int w)
	{
		he[m] = v;
		ev[m] = w;
		ne[m] = fe[u];
		fe[u] = m++;
	}
	inline void insert(int u, int v, int w)
	{
		insert_directed(u, v, w);
		insert_directed(v, u, w);
	}
};
glist g; int enc[M]; // Edge node count.
struct { int v, e, r; } stk[N]; bool vst[N];
inline void count_node(int index)
{
	int t = 0, w, cnt;
	memset(enc, 0, sizeof enc);
	memset(vst, false, sizeof vst);
	stk[0].v = index; // init stack.
__0:
	vst[stk[t].v] = true;
	stk[t].r = 1; // result = 1;
	stk[t].e = g.fe[stk[t].v];
	while (stk[t].e != -1)
	{
		w = g.he[stk[t].e];
		if (!vst[w])
		{
			++t; stk[t].v = w; goto __0; // ? = dfs(w);
__1:
			cnt = stk[t+1].r; // cnt = dfs(w);
			stk[t].r += cnt; // result += cnt;
			enc[stk[t].e>>1] = min(cnt, g.n - cnt);
		}
		stk[t].e = g.ne[stk[t].e];
	}
	if (t > 0)
	{
		--t; goto __1; // return result;
	}
}
int main()
{
	// freopen("input.txt", "r", stdin);
	// freopen("output.txt", "w", stdout);
	int T, n;
	scanf("%d", &T);
	for (int k = 1; k <= T; ++k)
	{
		scanf("%d", &n);
		g.reset(n);
		for (int i = 1; i < n; ++i)
		{
			int u, v, w;
			scanf("%d %d %d", &u, &v, &w);
			--u; --v;
			g.insert(u, v, w);
		}
		count_node(0);
		ull result = 0;
		for (int i = 0; i < g.m; i += 2)
			result += ull(enc[i>>1]) * ull(g.ev[i]);
		printf("Case #%d: %llu\n", k, (result * 2ull));
	}
	return 0;
}

数据生成器源代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;
const int N = 111111;
inline int rnd()
{
	return (rand() * rand()) & 0x7fffffff;
}
struct tree_generator
{
	int r[N], n;
	inline void reset(int sz)
	{
		n = sz;
		for (int i = 0; i < n; ++i)
			r[i] = i;
	}
	int find(int x)
	{
		return r[x] = (x == r[x] ? x : find(r[x]));
	}
	inline void merge(int x, int y)
	{
		r[find(x)] = find(y);
	}
	inline void generate()
	{
		int x, y, w, k; bool flag = true;
		for (int i = 1; i < n; ++i)
		{
			k = 0; flag = true;
			do
			{
				if (++k < 100)
					x = rnd() % n;
				else
					for (x = 0; flag; ++x)
					{
						if (find(x) == x)
						{
							if (rand() & 1) break;
							for ( ; find(x) != x; ++x);
							flag = false;
						}
					}
				y = rnd() % n;
			}
			while (find(x) == find(y));
			w = rnd() % 1000000 + 1;
			cout << x + 1 << ' ' << y + 1 << ' ' << w << endl;
			merge(x, y);
			if (!(i % 1000)) cerr << i << ' ';
		}
	}
};
tree_generator generator;
int main()
{
	freopen("input.txt", "w", stdout);
	srand((unsigned int)time(NULL));
	int T = 10;
	cout << T << endl << endl;
	while (T--)
	{
		unsigned int n = rnd() % 98765 + 3;
		cout << n << endl << endl;
		cerr << "==== " << T << ':' << n << endl;
		generator.reset(n);
		generator.generate();
		cout << endl << endl;
		cerr << endl << endl;
	}
	return 0;
}