2016 10 26考试 NOIP模拟赛 杂题

#####Time 7：50 AM -> 11：15 AM
感觉今天考完后，我的内心是崩溃的

---

试题

考试包

---

T1：

首先看起来是个贪心，然而，然而，看到那个100%数据为n <= 2000整个人就虚了，发呆接近两小时后意识到这个应该是个dp，然后开始考虑dp方程，脑残把dp打成了n^3，果断上天。。而且在转移过程中推错多打了一个-1，于是3个wa 1个ac 6个TLE ，10分滚粗

T1 dp 正解：

使用二维dp记录当前状态，dp[i][j]表示在前i个妖精中选择了j个妖精的最小时间，转移过程如下：

1、

如果dp[i-1][j] != inf dp[i][j] = min(dp[i][j], dp[i-1][j]);

2、

如果dp[i-1][j-1] != inf 即可以转移，如果dp[i-1][j-1] < l[i] 那么dp[i][j] = min(dp[i][j], l[i] + t[i] -1)，否则dp[i][j] = min(dp[i][j], dp[i-1][j-1] + t[i]);最后逆序枚举dp[n][i]输出第一个小于inf的i值即为答案

#include <cstdio>
#include <cstring>
#include <algorithm>

const int maxn = 2000 + 100;

int dp[maxn][maxn];
int li[maxn], ri[maxn], ti[maxn];
int n;

int main () {
	freopen("sanae.in", "r", stdin);
	freopen("sanae.out", "w", stdout);
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) scanf("%d %d %d", &li[i], &ri[i], &ti[i]);
	memset(dp, 127, sizeof(dp));
	for (int i = 0; i <= n; i++) dp[i][0] = 0;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= i; j++) {
			if (dp[i-1][j] != 0x3f3f3f3f) {
					dp[i][j] = std :: min(dp[i][j], dp[i-1][j]);
				}
				if (dp[i-1][j-1] != 0x3f3f3f3f) {
					if (dp[i-1][j-1] < li[i]) dp[i][j] = std :: min(li[i] + ti[i] - 1, dp[i][j]);
					else {
						int cend = dp[i-1][j-1] + ti[i];
						if (cend <= ri[i]) {
							dp[i][j] = std :: min(dp[i][j], cend);
						}
					}
				}
		}
	for (int i = n; i >= 0; i--)
		if (dp[n][i] < 0x3f3f3f3f) {
			printf("%d", i);
			break;
		}
	return 0;
}

/*
7
3 12 6
7 13 6
9 14 3
13 22 7
13 24 5
16 24 3
16 26 6
 */

T3

历经一下午思考以及apt123大神讲解，终于算是A了这道world final的B题。考试时看到数据范围，果断的写了dfs，30分到手，也算是勉强弥补了一下第一题的坑

先来粘一下作者给的无比详细(shi fen jian lue)的题解

我们将所有给出的三元环看做点，把所有边也看成点。把三元环所对应的点与组成这个三元环的边所对应的点连线，这样我们就得到了一棵树。问题转化为：在这棵树上取一棵有最多叶子结点的子树，满足：

1、 代表原三元环的点的所有连出的边都可以选。

2、 代表原边的点只能选两条连出的边。

树形dp即可。

呵呵

再来看一下gcj给的题解

This proved to be the easiest problem in the finals for the experienced competitors.

We get some insight into the problem by noticing the graph resembles a tree. These graphs are actually called partial 2-trees. We can actually build a tree if we follow the way the graph is constructed. We build another graph that associates a node to each new added cycle of length this cycle shares an edge to an old cycle so we add an edge between the two respective nodes in the second graph. This way we have built the tree decomposition of these graphs. As on trees many problems that are hard to solve on general graphs have polynomial algorithms on this type of graphs.

Let's solve the related problem of finding the longest path in a tree. We can use dynamic programming and depth first search. We mark a node as a root. Every path in the tree has exactly one node that is closest to the root and this node splits the path in two downward paths. Now for each node in the tree we compute the longest downwards path that starts in it. To find the largest path in the tree we look at each node and at the two longest paths that start in it's children. This solves the problem in linear time.

The solution for our original problem is pretty similar. For each edge (x,y), we compute the cycle that contains it and and all the other nodes in the cycle have larger indexes. Let's call this a downward cycle since it goes the opposite direction of where the initial three nodes are. To find that number we have to look at all higher indexed nodes that were connected to this edge and try to use them as intermediary points in the cycle. So for a given intermediary point z we can build a cycle by looking at the longest downward cycle that contains the edge (x,z) and the longest downward cycle that contains the edge (z,y), use all the edges, add edge (x,y) and remove the edges (x,z) and (z,y).

We also compute the largest downward cycle which contains these two nodes but doesn't contain this edge, this is a union of the cycle that goes through these nodes and the second largest path from which we remove the edge (x,y).

呵呵

好吧我们开始自食其力

T3题解 以及 我对T3的理解：

很显然这张图不是一般的图（废话），我们不难发现这张图实际上是由若干个小三角形组成的（即题解中所说的三元组），那么对于



这种形状的图来说，我们只能从中选取两个三角形来进行操作，从而推知，对于任意一条边，最多只有两个与之相连三角形被选取，因此，可以选择从四周向中间的123转移

设a数组记录了每个点连出去的两个点，用每个后加入点的标号表示三角形的标号，b数组代表从其余两个方向递推过来时的最大值，



即图中的7 -> 5 和 6 -> 5，c数组表示通过1、2、3边的最大值，为保证转移正确在读入时直接保证a[i][0] < a[i][1]，之后每一步根据转移目标是否为123的三角形进行分情况讨论并转移，注意每一步需要尝试更新ans值， ans值并不一定会在123三角形中取得。注意转移细节，详见代码。

#include <cstdio>
#include <algorithm>
#include <cstring>

const int maxn = 100000 + 100;
int a[maxn][2];
int b[maxn][2];
int c[100][100];
int n;
int ans = 0;

int main () {
	freopen("aya.in", "r", stdin);
	freopen("aya.out", "w", stdout);
	scanf("%d", &n);
	for (int i = 4; i <= n; i++) {
		scanf("%d %d", &a[i][0], &a[i][1]);
		if (a[i][0] > a[i][1]) {
			int t = a[i][0];
			a[i][0] = a[i][1];
			a[i][1] = t;
		}
	}
	for (int i = n; i >= 4; i--) {
		if (a[i][1] < 4) {
			ans = std :: max(ans, c[a[i][0]][a[i][1]] + b[i][1] + b[i][0] + 3);
			c[a[i][0]][a[i][1]] = std :: max(c[a[i][0]][a[i][1]], b[i][1] + b[i][0] + 1);
		} else {
			if (a[a[i][1]][0] == a[i][0]) {
				ans = std :: max(ans, b[a[i][1]][0] + b[i][0] + b[i][1] + 3);
				b[a[i][1]][0] = std :: max(b[a[i][1]][0], b[i][0] + b[i][1] + 1);
			} else {
				ans = std :: max(ans, b[a[i][1]][1] + b[i][1] + b[i][0] + 3);
				b[a[i][1]][1] = std :: max(b[a[i][1]][1], b[i][0] + b[i][1] + 1);
			}
		}
	}
	ans = std :: max(ans, c[1][2] + c[2][3] + c[1][3] + 3);
	printf("%d", ans);
	return 0;
}

以及R神的pascal代码

var
n,i,j,ans:longint;
a,b:array[1..100000,1..2]of longint;
bb:array[1..3,1..3]of longint;
function max(a,b:longint):longint;
begin
  if a>b then exit(a);exit(b);
end;
begin
  assign(input,'aya.in');
  reset(input);
  assign(output,'aya.out');
  rewrite(output);
  readln(n);
  for i:=4 to n do
    begin
    readln(a[i,1],a[i,2]);
    if a[i,1]>a[i,2] then
      begin
      j:=a[i,1];
      a[i,1]:=a[i,2];
      a[i,2]:=j;
      end;
    end;
  for i:=n downto 4 do
    begin
    if a[i,2]<4 then
      begin
      ans:=max(ans,bb[a[i,1],a[i,2]]+b[i,1]+b[i,2]+3);
      bb[a[i,1],a[i,2]]:=max(bb[a[i,1],a[i,2]],b[i,1]+b[i,2]+1);
      end
      else
        begin
        if a[a[i,2],1]=a[i,1] then
          begin
          ans:=max(ans,b[a[i,2],1]+b[i,1]+b[i,2]+3);
          b[a[i,2],1]:=max(b[a[i,2],1],b[i,1]+b[i,2]+1);
          end
          else
            begin
            ans:=max(ans,b[a[i,2],2]+b[i,1]+b[i,2]+3);
            b[a[i,2],2]:=max(b[a[i,2],2],b[i,1]+b[i,2]+1);
            end;
        end;
    end;
  ans:=max(ans,bb[1,2]+bb[1,3]+bb[2,3]+3);
  writeln(ans);
  close(input);
  close(output);
end.

完