NKOJ P2017——渡轮问题(变态版)

问题描述

NK河的两岸各有N个城市，且北岸的每一个城市与南岸的某个城市是友好城市，而且对应的关系是一一对应的。现在要求在两个个友好城市之间建立一条航线，但所有航线都不能相交，因此，就不可能给所有的友好城市建立航线。问题：当城市间的友好关系建立以后，选择一种修建航线的方案，使得能建最多的不相交的航线？

输入格式

第一行，一个整数N，(N<=100000)
第二行，N个空格间隔的整数，表示第i个数表示北岸的编号i个城市对应南岸的友好城市的编号

输出格式

一行，一个整数，表示最大航线数

样例输入

样例输入1：
7
4 3 5 7 1 6 2

样例输入2：
9
5 8 9 2 3 1 7 4 6

样例输出

样例输出1：
3

样例输出2：
4

提示

注意：N大的变态

---

第一眼一看：这是一道DP。但怎么推出状态转移方程呢？

根据题目，可以看出：

[1, 4], [3, 5], [4, 7]

[2, 3], [3, 5], [4, 7]

[1, 4], [3, 5], [6, 6]

[2, 3], [3, 5], [6, 6]

这四种都是最佳情况，最多可建立3条航道

已知北岸是递增序列，我们来看南岸：
[4, 5, 7]

[3, 5, 7]

[4, 5, 6]

[3, 5, 6]

也都是递增序列

so，这道题就是求最长不下降子序列 ：当i < j, a[i] < a[j] 或 i > j, a[i] > a[j]的情况下航线不相交

#include <iostream>
using namespace std;

int n;
int a[5005], f[5005], ans;

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
		f[i] = 1;
	}
	for (int i = n; i > 0; i--) {
		for (int j = i + 1; j <= n; j++) {
			if (a[i] < a[j]) {
				f[i] = max(f[j] + 1, f[i]);
			}
			ans = max(f[i], ans);
		}
	}
	printf("%d", ans);
	return 0;
}

！但是  ！

“(N<=100000)”     “注意：N大的变态”

题目名称
渡轮问题(变态版)
判题结果
Time Limit Exceeded
语言
C++
总用时
3025 MS
最大用时
1060 MS
最大内存
8856 KB
总得分
40
测试点 1
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 2
TLE    时间: 1060 MS    空间: 8836 KB    得分: 0
测试点 3
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 4
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 5
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 6
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 7
WA    时间: 0 MS    空间: 0 KB    得分: 0
测试点 8
TLE    时间: 1029 MS    空间: 8856 KB    得分: 0
测试点 9
TLE    时间: 936 MS    空间: 8528 KB    得分: 0
代码长度
390 B

这样算会TLE的～

那么，首先讲一个更暴力的算法 （别着急问为什么）

1.状态：f[i] 表示以a[i]结尾的最长上升子序列长度

         检查是否有 f[j] == x && a[j] < a[i] 的j的存在，如果有：f[i] = x + 1并停止枚举x 

2.时间复杂度

        枚举x时，检查j： O(n)

        枚举f[i]：枚举x，i —— O(n ^ 2)

于是可以计算出时间复杂度为O(n  ^ 3)

更加TLE......冷静！现在，我们来优化这个算法

1.优化枚举x的速度

        假定我们知道f[i]的真实值：

                if (x >= f[i]) : 一定找不到 (f[j] == x && a[j] < a[i]) 的 j；

                else ： 一定能找到

        你想到了什么？

        bfs,dfs......

       二分查找啊！

		int x = lower_bound(g, g + ans + 1, a) - g;
	

此时的时间复杂度： O(n ^ 2 log n)

还是TLE...... （n ^ 2 log n 很明显大于 n ^ 2）

冷静！还能优化！、

2.优化枚举j的速度

        空间换时间，设g[x]表示f[j] == x的所有j中，最小的a[j]的值

        于是当检查是否有符合条件的j是，只需判断g[x] 和 a[i]的关系

		int x = lower_bound(g, g + ans + 1, a) - g;
		ans = ans < x ? x : ans;

时间复杂度：O(n log n)

不会TLE了

怎么写程序呢？

变量m记录g数组的有效部分长度，一开始g[0]要初始化成很小的树

最终，m就是答案

		int x = lower_bound(g, g + ans + 1, a) - g;
		ans = ans < x ? x : ans;
		g[x] = a;

想要完整代码？没门！！！

---

THE END