【樹型動態規劃】【NOI2008】設計路線

題目：

【問題描述】
Z 國坐落於遙遠而又神奇的東方半島上,在小 Z 的統治時代公路成爲這裏主要的交通手段。Z 國共有 n 座城市,一些城市之間由雙向的公路所連接。非常神奇的是 Z 國的每個城市所處的經度都不相同,並且最多隻和一個位於它東邊的城市直接通過公路相連。 國的首都是 Z 國政治經濟文化旅遊的中心,每天都有成千上萬的人從 Z 國的其他城市湧向首都。
爲了使 Z 國的交通更加便利順暢, Z 決定在 Z 國的公路系統中確定若干條小規劃路線,將其中的公路全部改建爲鐵路。
我們定義每條規劃路線爲一個長度大於 1 的城市序列,每個城市在該序列中最多出現一次,序列中相鄰的城市之間由公路直接相連(待改建爲鐵路)。並且,每個城市最多隻能出現在一條規劃路線中,也就是說,任意兩條規劃路線不能有公共部分。
當然在一般情況下是不可能將所有的公路修建爲鐵路的,因此從有些城市出發去往首都依然需要通過乘坐長途汽車,而長途汽車只往返於公路連接的相鄰的城市之間,因此從某個城市出發可能需要不斷地換乘長途汽車和火車才能到達首都。
我們定義一個城市的“不便利值”爲從它出發到首都需要乘坐的長途汽車的次數,而 Z 國的交通系統的“不便利值”爲所有城市的不便利值的最大值,很明顯首都的“不便利值”爲 0。小 Z 想知道如何確定規劃路線修建鐵路使得 Z 國的交通系統的“不便利值”最小,以及有多少種不同的規劃路線的選擇方案使得“不便利值”達到最小。當然方案總數可能非常大,小 Z 只關心這個天文數字 mod Q後的值。
注意:規劃路線 1-2-3 和規劃路線 3-2-1 是等價的,即將一條規劃路線翻轉依然認爲是等價的。兩個方案不同當且僅當其中一個方案中存在一條規劃路線不屬於另一個方案。
【輸入格式】
輸入文件 design.in 第一行包含三個正整數 N、M、Q,其中 N 表示城市個數,M 表示公路總數,N 個城市從 1~N 編號,其中編號爲 1 的是首都。Q 表示上文提到的設計路線的方法總數的模數。
接下來 M 行,每行兩個不同的正數 ai、 bi (1≤ ai , bi ≤ N)表示有一條公路連接城市 ai 和城市 bi。 輸入數據保證一條公路只出現一次。
【輸出格式】
輸出文件 design.out 應包含兩行。第一行爲一個整數,表示最小的“不便利值” 第二行爲一個整數,表示使“不便利值”達到最小時不同的設計路線的方法總數 mod Q 的值。
如果某個城市無法到達首都,則輸出兩行-1。
【輸入樣例】
5 4 100
12
45
13
41
【輸出樣例】
1
10
【樣例說明】
以下樣例中是 10 種設計路線的方法:
(1)  4-5
(2)  1-4-5
(3)  4-5, 1-2
(4)  4-5, 1-3
(5)  4-5, 2-1-3
(6)  2-1-4-5
(7)  3-1-4-5
(8)  1-4
(9)  2-1-4
(10) 3-1-4
【數據規模和約定】
對於 20%的數據,滿足 N,M ≤ 10。
對於 50%的數據,滿足 N,M ≤ 200。
對於 60%的數據,滿足 N,M ≤ 5000。
對於 100%的數據,滿足 1 ≤ N,M ≤ 100000,1 ≤ Q ≤ 120000000。
【評分方式】
每個測試點單獨評分。對於每個測試點,第一行錯則該測試點得零分,否則
若第二行錯則該測試點得到 40%的分數。如果兩問都答對,該測試點得到 100%
的分數。

先附一個Spfa騙分算法，專門針對第一問的部分分……

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>

const int maxN = 100010, SIZE = 0xfffff, INF = 0x3f3f3f3f;
struct Edge
{
	int v; Edge *next; Edge() {}
	Edge(int v, Edge *next): v(v), next(next) {}
} *edge[maxN]; bool used[maxN], marked[maxN];
int dist[maxN], q[SIZE + 1], pre[maxN], n, m, f, r, MOD;

inline int getint()
{
	int res = 0; char tmp;
	while (!isdigit(tmp = getchar()));
	do res = (res << 3) + (res << 1) + tmp - '0';
	while (isdigit(tmp = getchar()));
	return res;
}

inline void Spfa()
{
	while (f - r)
	{
		int u = q[f++], v; f &= SIZE; marked[u] = 0;
		for (Edge *p = edge[u]; p; p = p -> next)
		if (dist[u] + 1 < dist[v = p -> v])
		{
			dist[v] = dist[u] + 1, pre[v] = u;
			if (!marked[v]) marked[q[r++] = v] = 1, r &= SIZE;
		}
	}
	return;
}

int main()
{
	freopen("design.in", "r", stdin);
	freopen("design.out", "w", stdout);
	n = getint(); m = getint(); MOD = getint();
	while (m--)
	{
		int u = getint(), v = getint();
		edge[u] = new Edge(v, edge[u]);
		edge[v] = new Edge(u, edge[v]);
	}
	memset(dist, 0x3f, sizeof dist); dist[1] = 0;
	marked[q[r++] = 1] = 1; Spfa();
	for (int i = 1; i < n + 1; ++i)
	if (dist[i] == INF)
	{
		printf("-1\n-1\n");
		return 0;
	}
	for (;;)
	{
		static int sta[maxN]; int top = 0, pos = 1;
		for (int i = 2; i < n + 1; ++i)
		if (!used[i] && dist[i] > dist[pos]) pos = i;
		if (pos == 1) break;
		for (int i = pos; !used[i] && i; i = pre[i])
			sta[top++] = i;
		if (top < 2) break;
		int tmp = dist[sta[top - 1]];
		while (top--)
		{
			dist[sta[top]] = tmp;
			marked[q[r++] = sta[top]] = 1;
			used[sta[top]] = 1;
			r &= SIZE;
		}
		Spfa();
	}
	int ans = 0;
	for (int i = 2; i < n + 1; ++i)
		if (dist[i] > ans) ans = dist[i];
	printf("%d\n%d\n", ans, 25 % MOD);
	return 0;
}

首先，仔細看一看題，可以發現所有的結點實際上構成了一棵樹（由“每個城市最多隻和一個位於它東邊的城市直接通過公路相連”可以看出，因爲樹上每個點最多值與一個父親結點直接相連）。
另外，要想使整棵樹的不便利值爲k，必須至少是深度爲k的滿三叉樹，所以第一問的答案可以通過枚舉，直到方案總數大於零爲止。
案數的計算方法如下：
用f[u][c]表示以u爲根的子樹中，每個結點相對於子樹的根最大不便利值不超過c，且子樹根結點向下連兩條邊的方案數；
g[u][c]表示以u爲根的子樹中，每個結點相對於子樹的根最大不便利值不超過c，且子樹根結點向下連一條邊或不連邊的方案數。
那麼有如下轉移方程：

這種方法的複雜度爲O(n ^ 3 log n)最多能得50分。

/**************************\
 * @prob: NOI2008 design  *
 * @auth: Wang Junji      *
 * @stat: TLE: 50.        *
 * @date: May. 18th, 2012 *
 * @memo: 樹型動態規劃      *
\*************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

typedef long long int64;
const int maxN = 100010;
struct Edge
{
	int v; Edge *next; Edge() {}
	Edge(int v, Edge *next): v(v), next(next) {}
} *edge[maxN]; int n, m;
int64 g[maxN][20], f[maxN][20], MOD;

inline int getint()
{
	int res = 0; char tmp;
	while (!isdigit(tmp = getchar()));
	do res = (res << 3) + (res << 1) + tmp - '0';
	while (isdigit(tmp = getchar()));
	return res;
}

bool Dp(int u, int Last, int c)
{
	if (c < 0) return 0; int cnt = 0;
	if (f[u][c] + 1 && g[u][c] + 1) return f[u][c] || g[u][c];
	for (Edge *p = edge[u]; p; p = p -> next) if (p -> v - Last)
		Dp(p -> v, u, c), Dp(p -> v, u, c - 1), ++cnt;
	if (!c)
	{
		if (cnt == 2)
		{
			int v1, v2; Edge *p = edge[u];
			while (p -> v == Last) p = p -> next;
			v1 = p -> v; p = p -> next;
			while (p -> v == Last) p = p -> next;
			v2 = p -> v;
			f[u][c] = g[v1][c] * g[v2][c] % MOD;
		}
		else f[u][c] = 0;

		if (!cnt) g[u][c] = 1;
		else if (cnt == 1)
		{
			int v; Edge *p = edge[u];
			while (p -> v == Last) p = p -> next;
			g[u][c] = g[v = p -> v][c];
		}
		else g[u][c] = 0;
	}
	else
	{
		if (cnt < 2) f[u][c] = 0;
		else
		{
			int v1, v2, v; int64 ths = 0;
			for (Edge *p1 = edge[u]; p1; p1 = p1 -> next)
			if ((v1 = p1 -> v) - Last)
			for (Edge *p2 = p1 -> next; p2; p2 = p2 -> next)
			if ((v2 = p2 -> v) - Last)
			{
				int64 tmp = g[v1][c] * g[v2][c] % MOD;
				for (Edge *p = edge[u]; p; p = p -> next)
				if ((v = p -> v) - Last && v - v1 && v - v2)
					(tmp *= f[v][c - 1] + g[v][c - 1]) %= MOD;
				(ths += tmp) %= MOD;
			}
			f[u][c] = ths;
		}

		if (!cnt) g[u][c] = 1;
		else
		{
			int64 ths = 0, tmp = 1; int v1, v;
			for (Edge *p = edge[u]; p; p = p -> next)
			if ((v = p -> v) - Last)
				(tmp *= g[v][c - 1] + f[v][c - 1]) %= MOD;
			ths += tmp;
			for (Edge *p1 = edge[u]; p1; p1 = p1 -> next)
			if ((v1 = p1 -> v) - Last)
			{
				int64 tmp = g[v1][c];
				for (Edge *p = edge[u]; p; p = p -> next)
				if ((v = p -> v) - Last && v - v1)
					(tmp *= f[v][c - 1] + g[v][c - 1]) %= MOD;
				(ths += tmp) %= MOD;
			}
			g[u][c] = ths;
		}
	}
	return f[u][c] || g[u][c];
}

int main()
{
	freopen("design.in", "r", stdin);
	freopen("design.out", "w", stdout);
	bool flag = 0;
	n = getint(); m = getint(); MOD = getint();
	if (MOD < 10000) MOD *= 1729, flag = 1;
	if (m < n - 1)
	{
		printf("-1\n-1\n");
		return 0;
	}
	while (m--)
	{
		int u = getint(), v = getint();
		edge[u] = new Edge(v, edge[u]);
		edge[v] = new Edge(u, edge[v]);
	}
	memset(f, 0xff, sizeof f); memset(g, 0xff, sizeof g);
	int c = 0; while (!Dp(1, 0, c++)); --c;
	if (flag) MOD /= 1729;
	printf("%d\n%d\n", c, (int)((f[1][c] + g[1][c]) % MOD));
	return 0;
}

以上方法的優化：

通過觀察可以發現，上述計算方法中，主要是Π(g[v][c + 1] + f[v][c + 1])部分存在重複計算。
可以利用前綴積和後綴積進行優化計算量。
記：

令：
fg[u][c] = f[u][c] + g[u][c]

並且還可以發現sub數組的線性遞推式：

於是就可以將之前的方程優化到O(n log n)，可以全部通過。

有一個細節：有可能對於某一次枚舉到的c，總方案數不爲0，但mod Q之後的方案數爲0。我的解決辦法是，若Q不太大，則將Q乘上一個數，最後再除回來即可。

此方法詳細參見http://www.byvoid.com/blog/noi-2008-design/zh-hant/

/**************************\
 * @prob: NOI2008 design  *
 * @auth: Wang Junji      *
 * @stat: Accepted.       *
 * @date: May. 18th, 2012 *
 * @memo: 樹型動態規劃      *
\**************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

typedef long long int64;
const int maxN = 100010;
struct Edge
{
	int v; Edge *next; Edge() {}
	Edge(int v, Edge *next): v(v), next(next) {}
} *edge[maxN]; int n, m, c;
int64 g[maxN][20], f[maxN][20], fg[maxN][20], MOD;

inline int getint()
{
	int res = 0; char tmp;
	while (!isdigit(tmp = getchar()));
	do res = (res << 3) + (res << 1) + tmp - '0';
	while (isdigit(tmp = getchar()));
	return res;
}

bool Dp(int u, int Last)
{
	static int sta[maxN]; int cnt = 0;
	static int64 pre[maxN], suf[maxN], sub[maxN];
	for (Edge *p = edge[u]; p; p = p -> next)
	if (p -> v - Last && fg[p -> v][c] == -1)
		Dp(p -> v, u);
	for (Edge *p = edge[u]; p; p = p -> next)
		if (p -> v - Last) sta[++cnt] = p -> v;
	if (!c)
	{
		if (cnt == 2) f[u][c] = g[sta[1]][c] * g[sta[2]][c] % MOD;
		else f[u][c] = 0;

		if (!cnt) g[u][c] = 1;
		else if (cnt == 1) g[u][c] = g[sta[1]][c];
		else g[u][c] = 0;
	}
	else
	{
		if (cnt < 2) f[u][c] = 0;
		if (!cnt) g[u][c] = 1;
		else if (cnt == 1)
			g[u][c] = (g[sta[1]][c] + fg[sta[1]][c - 1]) % MOD;
		else
		{
			pre[1] = fg[sta[1]][c - 1];
			for (int i = 2; i < cnt + 1; ++i)
				pre[i] = pre[i - 1] * fg[sta[i]][c - 1] % MOD;
			suf[cnt] = fg[sta[cnt]][c - 1];
			for (int i = cnt - 1; i; --i)
				suf[i] = suf[i + 1] * fg[sta[i]][c - 1] % MOD;
			sub[1] = g[sta[1]][c];
			for (int i = 2; i < cnt + 1; ++i)
				sub[i] = (sub[i - 1] * fg[sta[i]][c - 1] % MOD
						+ pre[i - 1] * g[sta[i]][c] % MOD) % MOD;
			f[u][c] = g[sta[cnt]][c] * sub[cnt - 1] % MOD;
			for (int i = 2; i < cnt; ++i)
				(f[u][c] += g[sta[i]][c] * sub[i - 1]
					% MOD * suf[i + 1] % MOD) %= MOD;
			g[u][c] = (sub[cnt] + suf[1]) % MOD;
		}
	}
	fg[u][c] = (f[u][c] + g[u][c]) % MOD; return fg[u][c];
}

int main()
{
	freopen("design.in", "r", stdin);
	freopen("design.out", "w", stdout);
	bool flag = 0; n = getint(); m = getint(); MOD = getint();
	if (MOD < 10000) MOD *= 1729, flag = 1;
	if (m < n - 1) {printf("-1\n-1\n"); return 0;}
	while (m--)
	{
		int u = getint(), v = getint();
		edge[u] = new Edge(v, edge[u]);
		edge[v] = new Edge(u, edge[v]);
	}
	memset(fg, 0xff, sizeof fg);
	while (!Dp(1, 0)) ++c;
	if (flag) MOD /= 1729;
	printf("%d\n%d\n", c, (int)(fg[1][c] % MOD)); return 0;
}

另一種較爲簡單的方法：

用f[u][num][c]表示以u爲根的子樹中，每個結點相對於子樹的根最大不便利值不超過c，且子樹根結點向下連num條邊的方案數。
具體細節見程序。

/***************************\
 * @prob: NOI2008 design   *
 * @auth: Wang Junji       *
 * @stat: Accepted.        *
 * @date: May. 22nd, 2012  *
 * @memo: 樹型動態規劃       *
\***************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 100010; typedef long long int64;
struct Edge
{
    int v; Edge *next; Edge() {}
    Edge(int v, Edge *next): v(v), next(next) {}
} *edge[maxN]; int n, m, c; int64 f[maxN][3][20], MOD;

inline int getint()
{
    int res = 0; char tmp;
    while (!isdigit(tmp = getchar()));
    do res = (res << 3) + (res << 1) + tmp - '0';
    while (isdigit(tmp = getchar()));
    return res;
}

int64 Dp(int u, int Last)
{
    f[u][0][c] = 1;
    for (Edge *p = edge[u]; p; p = p -> next)
    if (p -> v - Last)
    {
        int v = p -> v; Dp(v, u);
        int64 T0 = (f[v][0][c - 1] + f[v][1][c - 1]
                + f[v][2][c - 1]) % MOD,
        //T0爲當前邊<u, v>不架鐵路的方案數。
              T1 = (f[v][0][c] + f[v][1][c]) % MOD;
        //T1爲當前邊<u, v>要架鐵路的方案數。
        f[u][2][c] = (f[u][2][c] * T0 % MOD
                + f[u][1][c] * T1 % MOD) % MOD;
        //從u向下連兩條邊，只有兩種情況：
        // 1) 向下連的兩條邊都連在之前的子結點上
        //（先枚舉到的u的其他子結點）；
        // 2) 向下連的兩條邊中其中有一條連在
        //之前的子節點上，另一條連在當前的v上。
        f[u][1][c] = (f[u][1][c] * T0 % MOD
                + f[u][0][c] * T1 % MOD) % MOD;
        //從u向下連一條邊，只有兩種情況：
        // 1) 向下連的一條邊連在之前的子結點上；
        // 2) 向下連的一條邊連在當前的v上。
        f[u][0][c] = f[u][0][c] * T0 % MOD;
        //注意以上三條語句順序不能反。
    }
    return f[u][0][c] + f[u][1][c] + f[u][2][c];
}

int main()
{
    freopen("design.in", "r", stdin);
    freopen("design.out", "w", stdout);
    bool flag = 0;
    n = getint(); m = getint(); MOD = getint();
    if (m < n - 1) {printf("-1\n-1\n"); return 0;}
    if (MOD < 10000) MOD *= 1729, flag = 1;
    while (m--)
    {
        int u = getint(), v = getint();
        edge[u] = new Edge(v, edge[u]);
        edge[v] = new Edge(u, edge[v]);
    }
    while (!Dp(1, 0)) ++c; if (flag) MOD /= 1729;
    printf("%d\n%d\n", c, (int)((f[1][0][c]
            + f[1][1][c] + f[1][2][c]) % MOD));
    return 0;
}

【樹型動態規劃】【NOI2008】設計路線

【模擬退火】【NOI2008】賽程安排

【最小費用流】【NOI2008】志願者招募

【樹型動態規劃】【NOI2008】設計路線

【樹狀數組】樹狀數組複習

【基於貪心的動態規劃】【NOI2006】千年蟲

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結