巩固(1)

目录：

1.bfs,dfs,记忆化搜索

2.二分

3.并查集

4.二叉树

5.hash，尺取法

1.bfs,dfs,记忆化搜索
 记忆化搜索是一种典型的空间换时间的思想。
 记忆化搜索的典型应用场景是可能经过不同路径转移到相同状态的dfs问题。
洛谷P1434 [SHOI2002] 滑雪
 一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度会减小。
输入格式
输入的第一行为表示区域的二维数组的行数R和列数C。
下面是R 行，每行有C个数，代表高度(两个数字之间用1个空格间隔)。
输出格式
输出区域中最长滑坡的长度。
 思路：
直接dfs会TLE,需要记忆化进行优化。

#include<iostream>
using namespace std;
int vis[110][110];  
int Map[110][110];
int dir[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
int sx,sy,Max;
int dfs(int x,int y) {    
    if (vis[x][y])    
        return vis[x][y];  //记忆化搜索
    vis[x][y] = true;
    for (int i = 0; i < 4; i++) {
    //往四个方向搜索，取四个方向中距离最长的，然后 + 1，这就是这个点的结果了
        int x1 = x + dir[i][0];
        int y1 = y + dir[i][1];
        if (x1 > 0 && y1 > 0 && x1 <= sx && y1 <= sy && Map[x1][y1] < Map[x][y]) {
                  //不需要标记走过的点，因为有从高到低的判断
            dfs(x1, y1);
            vis[x][y] = max(vis[x][y], vis[x1][y1]+1);
        }
    }
    return vis[x][y];
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> sx >> sy;
    for (int i = 1; i <= sx; i++) {
        for (int j = 1; j <= sy; j++) {
            cin >> Map[i][j];
        }
    }
    for (int i = 1; i <= sx; i++) {    //枚举从每个点出发的最长路径
        for (int j = 1; j <= sy; j++) {
            Max = max(Max, dfs(i, j));  //记录最长路径
        }
    }
    cout << Max << endl;
}

数字三角形
编写一个程序，计算从顶部开始并在底部某处结束的路线上传递的最高数字总和。
每个步骤都可以沿对角线向下向左或沿对角线向下向右
输入
您的程序是从标准输入读取。第一行包含一个整数 N：三角形中的行数。
 以下 N 行描述了三角形的数据。三角形中的行数 > 1，但 <= 100。三角形中的数字（均为整数）介于 0 和 99 之间。
输出
您的程序将写入标准输出。最高总和写为整数。

#include<iostream>
using namespace std;
int a[110][110];
int vis[110][110];
int N;
int dfs(int x, int y) {
    if (x == N) {
        vis[x][y] = a[x][y];
        return vis[x][y];
    }
    if (vis[x][y])
        return vis[x][y];    //记忆化搜索
    vis[x][y] = max(vis[x][y], dfs(x + 1, y) + a[x][y]);  //沿对角线向下向左搜索
    vis[x][y] = max(vis[x][y], dfs(x + 1, y + 1) + a[x][y]); //沿对角线向下向右搜索
    return vis[x][y];
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> N;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= i; j++) {
            cin >> a[i][j];
        }
    }
    cout << dfs(1, 1) << '\n';
    return 0;
}

2.二分
模板1：（只要是往左找答案）

while (l < r){
    int mid = l + r >> 1;    //(l+r)/2
    if (check(mid))  r = mid;    // check()判断mid是否满足性质
    else l = mid + 1;
}

模板2：（只要是往右找答案）

while (l < r){
    int mid = l + r + 1 >> 1;    //(l+r+1)/2
    if (check(mid))  l = mid;
    else r = mid - 1;
}

模板3：（浮点二分）

while (r - l > 1e-5){ //需要一个精度保证
    double mid = (l + r) / 2;
    if (check(mid)) l = mid; //或r=mid;
    else r = mid; //或l=mid;
}

洛谷P1163 银行贷款（浮点二分）
输入格式
三个用空格隔开的正整数。
第一个整数表示贷款的原值，第二个整数表示每月支付的分期付款金额，
第三个整数表示分期付款还清贷款所需的总月数。
输出格式
一个实数，表示该贷款的月利率（用百分数表示），四舍五入精确到 0.1 % 。
 输入：
 1000 100 12
 输出：
 2.9

#include<iostream>
using namespace std;
int a, b, c;
bool check(double mid) {
    double a1 = a;
    for (int i = 0; i < c; i++) {
        a1 = a1 + a1 * mid - b;
    }
    if (a1 > 0)
        return false;
    return true;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> a >> b >> c;
    double r = 500, l = 0;
     while (r - l > 1e-5) { //需要一个精度保证
            double mid = (l + r) / 2;
            if (check(mid)) l = mid; //或r=mid;
            else r = mid; //或l=mid;
     }
     printf("%.1f", l*100 );
    return 0;
}

洛谷P2440 木材加工
木材厂有 n 根原木，现在想把这些木头切割成k段长度均为l的小段木头（木头有可能有剩余）。
当然，我们希望得到的小段木头越长越好，请求出l的最大值。
木头长度的单位是cm原木的长度都是正整数，我们要求切割得到的小段木头的长度也是正整数。
输入格式
第一行是两个正整数n, k，分别表示原木的数量，需要得到的小段的数量。接下来
n 行，每行一个正整数Li​表示一根原木的长度。
输出格式
仅一行，即l 的最大值。如果连1cm 长的小段都切不出来，输出 0。
求最长长度,模板2

#include<iostream>
using namespace std;
const int Maxn = 1e8 + 10;
long long a[Maxn], sum;          //a数组需要 long long
int n, k;
bool check(int mid) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += a[i] / mid;
    }
    if (sum >= k) return true; //总段数大于等于所需要的 
    return false;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> k;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        sum += a[i];
    }
    if (sum < k) {
        cout << 0;
        return 0;
    }
    int l = 1, r = 1e8+10;
    while (l < r){
    int mid = l + r + 1 >> 1;    //(l+r+1)/2
    if (check(mid))  l = mid;
    else r = mid - 1;
    }
    cout << l;
    return 0;
}

3.并查集
洛谷P2661 [NOIP2015 提高组] 信息传递
有n 个同学（编号为1 到n ）正在玩一个信息传递的游戏。
在游戏里每人都有一个固定的信息传递对象，其中，编号为i 的同学的信息传递对象是编号为Ti​的同学。
游戏开始时，每人都只知道自己的生日。
之后每一轮中，所有人会同时将自己当前所知的生日信息告诉各自的信息传递对象
（注意：可能有人可以从若干人那里获取信息， 但是每人只会把信息告诉一个人，
即自己的信息传递对象）。当有人从别人口中得知自 己的生日时，游戏结束。
请问该游戏一共可以进行几轮？
输入：
共2行
第1行包含1个正整数n,表示n个人。
第2行为Ti；
思路：
并查集求最小环
信息从自己出发又回到自己，必然是传递的路径形成了一个环。
当有人得知自己得信息时就结束，说明要在这个图中寻找一个最小的环。

#include<iostream>
using namespace std;
const int Maxn = 2e5 + 10;
int fa[Maxn];
int sum = 0x3f3f3f3f;
inline int find(int t, int& ans) {
    ans++;                       //记录环的长度
    return fa[t] == t ? t : find(fa[t],ans);// 如果构成了一个环，就不需要把这个环的结尾接上，否则会陷入死循环
}
int main() 
{
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        fa[i] = i;
    }
    for (int i = 1; i <= n; i++) {
        int ans = 0, t;
        cin >> t;
        if (find(t, ans) == i)
            sum = min(sum, ans);         //记录最小环
        else
            fa[i] = t;
    }
    cout << sum << '\n';
    return 0;
}

4.二叉树
P4715 【深基16.例1】淘汰赛
能力值高的国家和能力值低的国家踢比赛时高者获胜。
1 号国家和 2 号国家踢一场比赛，胜者晋级。3 号国家和 4 号国家也踢一场，胜者晋级……
晋级后的国家用相同的方法继续完成赛程，直到决出冠军。
给出各个国家的能力值，请问亚军是哪个国家？
输入格式:
第一行一个整数 n，表示一共 2 ^ n 个国家参赛。
第二行 2 ^ n 个整数，第i个整数表示编号为 $i$ 的国家的能力值,数据保证不存在平局。
输出格式:
仅一个整数，表示亚军国家的编号。

#include<iostream>
using namespace std;
int tree[10000], a[10000];
int n, flag = 0;
void build(int x, int m) {//建立二叉树
    if (m == n) {
        cin >> a[++flag];
        tree[x] = a[flag];
        return;
    }
    build(2 * x, m+1);//左结点，应为m+1不是m++
    build(2 * x + 1, m+1);  //右节点
    tree[x] = max(tree[x * 2], tree[x * 2 + 1]);

}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n;
    build(1, 0);
    int Min = min(tree[2], tree[3]);
    for (int i = 1; i <= 1 << n; i++) {//1<<n==2的n次方
        if (a[i] == Min) {    //找到季军所在编号
            cout << i << '\n';
            return 0;
        }
    }
    return 0;
}

5.hash
P1381 单词背诵
灵梦有 n 个单词想要背，但她想通过一篇文章中的一段来记住这些单词。
文章由m 个单词构成，她想在文章中找出连续的一段，
其中包含最多的她想要背的单词（重复的只算一个）。
并且在背诵的单词量尽量多的情况下，还要使选出的文章段落尽量短，
这样她就可以用尽量短的时间学习尽可能多的单词了。
输入格式
第1行一个数n，接下来n 行每行是一个长度不超过10 的字符串，表示一个要背的单词。
接着是一个数m，然后是m 行长度不超过10 的字符串，每个表示文章中的一个单词。
输出格式
输出文件共2 行。
第1行为文章中最多包含的要背的单词数，第2行表示在文章中包含最多要背单词的最短的连续段的长度。
思路：
 尺取法:在序列中寻找包含全部需求的，长度最小的一段子序列的O(n)的算法
 初始化左右下标l,r到适当位置;
不停的向右移动r，直到r出界或者[l, r]自区间已经满足要求
接下来ans = min(ans, r - l + 1)，注意程序中往往区间是指[l, r + 1]，所以ans = min(ans, r - l);
移动l到适当位置。重复第一个过程。
首先把所有串哈希一下，记录在n个串中出现的位置，然后用尺取法，
因为只让求满足出现最多单词的区间。注意特判边界的情况。
 

#include<iostream>
using namespace std;
typedef unsigned long long ull;
const ull mod = 1610612741;
int n, n1;
char s[110];
ull a[1010], b[1010];
bool vis[mod], vis1[mod];
ull Hash(char* s) {          //得到hash值
	ull res = 0;
	for (int i = 0; i < strlen(s); i++) {
		res *= 31, res += s[i] - 'a';
		res %= mod;
	}
	return res % mod;
}
int mian()
{
	ios::sync_with_stdio(false);
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> s;
		a[i] = Hash(s);
		vis[a[i]] = true;         //标记
	}
	cin >> n1;
	int sum = 0, sum1 = 0;
	for (int i = 1; i <= n1; i++) {
		cin >> s;
		b[i] = Hash(s);
		if (vis[b[i]] && !vis1[b[i]]) {
			sum++;                      //统计重合个数
			vis1[b[i]] = true;
		}
	}
	memset(vis1, 0, sizeof vis1);
	int l = 1, r = 1, cnt = sum;
	while (1) {
		if (!cnt) {
			while (!vis[b[l]]) l++;
			if (l == n1 + 1) break;
			sum1 = min(sum1, r - l);
			if (vis1[b[l]] == 1) cnt++;
			if (vis1[b[l]] >= 1) vis1[b[l]]=false, l++;
		}
		else {
			if (r == n1 + 1) break;
			if (vis[b[r]]) {
				if (!vis1[b[r]]) cnt--;
				vis1[b[r]]++;
			}
			r++;
		}
	}
	cout << sum << '\n' << sum1 << '\n';
	return 0;
}