（左程云）算法讲解096【必备】博弈类问题必备内容详解-下

原创 于 2025-05-08 00:39:58 发布 · 957 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

图游戏的概念
任何局面都认为是图中的点，每一个局面都可以通过一种行动，走向图中的下一个点
如果当前行动有若干个，那么后继节点就有若干个。最终，必败局面的点认为不再有后继节点
那么公平组合游戏（ICG），就可以对应成一张图

SG函数(Sprague-Grundy函数），如下是SG返回值的求解方式，俗称mex过程
最终必败点是A，规定SG(A) = 0
假设状态点是B，那么SG(B) = 查看B所有后继节点的sg值，其中没有出现过的最小自然数
SG(B) != 0，那么状态B为必胜态；SG(B) == 0，那么状态B为必败态

SG定理(Bouton定理)
如果一个ICG游戏（总），由若干个独立的ICG子游戏构成（分1、分2、分3…)，那么：
SG(总) = SG(分1) ^ SG(分2) ^ SG(分3)… 任何ICG游戏都是如此，正确性证明类似尼姆博弈
当数据规模较大时，要善于通过对数器的手段，打印SG表并观察，看看能不能发现简洁规律

SG（x）：不在后继节点的最小自然数

题目1：SG函数求解过程展示：巴什博弈

一共有n颗石子，两个人轮流拿，每次可以拿1~m颗石子
拿到最后一颗石子的人获胜，根据n、m返回谁赢
对数器验证
通过观察sg表，一样可以得到巴什博弈最简洁的结论

package class096;

import java.util.Arrays;

// 巴什博弈(SG函数求解过程展示)
// 一共有n颗石子，两个人轮流拿，每次可以拿1~m颗石子
// 拿到最后一颗石子的人获胜，根据n、m返回谁赢
// 对数器验证
public class Code01_BashGameSG {

	// 发现结论去求解，时间复杂度O(1)
	// 充分研究了性质
	public static String bash1(int n, int m) {
		return n % (m + 1) != 0 ? "先手" : "后手";
	}

	// sg函数去求解，时间复杂度O(n*m)
	// 不用研究性质
	// 其实把sg表打印之后，也可以发现性质，也就是打表找规律
	public static String bash2(int n, int m) {
		int[] sg = new int[n + 1];
		boolean[] appear = new boolean[m + 1];
		for (int i = 1; i <= n; i++) {
			Arrays.fill(appear, false);
			for (int j = 1; j <= m && i - j >= 0; j++) {
				appear[sg[i - j]] = true;
			}
			for (int s = 0; s <= m; s++) {
				if (!appear[s]) {
					sg[i] = s;
					break;
				}
			}
		}

//		System.out.println("打印 n = " + n + ", m = " + m + " 的sg表");
//		for (int i = 0; i <= n; i++) {
//			System.out.println("sg(" + i + ") : " + sg[i]);
//		}

		return sg[n] != 0 ? "先手" : "后手";
	}

	// 为了验证
	public static void main(String[] args) {
		int V = 1000;
		int testTimes = 10000;
		System.out.println("测试开始");
		for (int i = 0; i < testTimes; i++) {
			int n = (int) (Math.random() * V);
			int m = (int) (Math.random() * V);
			String ans1 = bash1(n, m);
			String ans2 = bash2(n, m);
			if (!ans1.equals(ans2)) {
				System.out.println("出错了!");
			}
		}
		System.out.println("测试结束");

		int n = 100;
		int m = 6;
		bash2(n, m);
	}

}

题目2：SG定理用法展示：尼姆博弈

一共有 n 堆石头，两人轮流进行游戏
在每个玩家的回合中，玩家需要 选择任一 非空 石头堆，从中移除任意 非零 数量的石头
如果不能移除任意的石头，就输掉游戏
返回先手是否一定获胜
对数器验证

通过观察sg表，以及分析总游戏的异或结果，一样可以得到尼姆博弈最简洁的结论

package class096;

import java.util.Arrays;

// 尼姆博弈(SG定理简单用法展示)
// 一共有 n 堆石头，两人轮流进行游戏
// 在每个玩家的回合中，玩家需要 选择任一 非空 石头堆，从中移除任意 非零 数量的石头
// 如果不能移除任意的石头，就输掉游戏
// 返回先手是否一定获胜
// 对数器验证
public class Code02_NimGameSG {

	// 时间复杂度O(n)
	// 充分研究了性质
	public static String nim1(int[] arr) {
		int eor = 0;
		for (int num : arr) {
			eor ^= num;
		}
		return eor != 0 ? "先手" : "后手";
	}

	// sg函数去求解
	// 过程时间复杂度高，但是可以轻易发现规律，进而优化成最优解
	// 证明不好想，但是从sg表出发，去观察最终的解，要好做很多
	public static String nim2(int[] arr) {
		int max = 0;
		for (int num : arr) {
			max = Math.max(max, num);
		}
		int[] sg = new int[max + 1];
		boolean[] appear = new boolean[max + 1];
		for (int i = 1; i <= max; i++) {
			Arrays.fill(appear, false);
			for (int j = 0; j < i; j++) {
				appear[j] = true;
			}
			for (int s = 0; s <= max; s++) {
				if (!appear[s]) {
					sg[i] = s;
					break;
				}
			}
		}
		// 打印sg表之后，可以发现，sg[x] = x
		// 那么eor ^= sg[num] 等同于 eor ^= num
		// 从sg定理发现了最优解
		int eor = 0;
		for (int num : arr) {
			eor ^= sg[num];
		}
		return eor != 0 ? "先手" : "后手";
	}

	// 为了验证
	public static int[] randomArray(int n, int v) {
		int[] ans = new int[n];
		for (int i = 0; i < n; i++) {
			ans[i] = (int) (Math.random() * v);
		}
		return ans;
	}

	public static void main(String[] args) {
		int N = 200;
		int V = 1000;
		int testTimes = 10000;
		System.out.println("测试开始");
		for (int i = 0; i < testTimes; i++) {
			int n = (int) (Math.random() * N) + 1;
			int[] arr = randomArray(n, V);
			String ans1 = nim1(arr);
			String ans2 = nim2(arr);
			if (!ans1.equals(ans2)) {
				System.out.println("出错了!");
			}
		}
		System.out.println("测试结束");
	}

}

题目3：两堆石头的巴什博弈

有两堆石头，数量分别为a、b
两个人轮流拿，每次可以选择其中一堆石头，拿1~m颗
拿到最后一颗石子的人获胜，根据a、b、m返回谁赢
来自真实大厂笔试，没有在线测试，对数器验证

通过观察sg表，以及分析总游戏的异或结果，一样可以得到最简洁的结论

public static int MAXN = 101;

public static String[][][] dp = new String[MAXN][MAXN][MAXN];

// 动态规划方法彻底尝试
// 为了验证
public static String win1(int a, int b, int m) {
    if (m >= Math.max(a, b)) {
        return a != b ? "先手" : "后手";
    }
    if (a == b) {
        return "后手";
    }
    if (dp[a][b][m] != null) {
        return dp[a][b][m];
    }
    String ans = "后手";
    for (int pick = 1; pick <= Math.min(a, m); pick++) {
        if (win1(a - pick, b, m).equals("后手")) {
            // 后续过程的赢家是后续过程的后手
            // 那就表示此时的先手，通过这个后续过程，能赢
            ans = "先手";
        }
        if (ans.equals("先手")) {
            // 后续过程的赢家是后续过程的后手
            // 那就表示此时的先手，通过这个后续过程，能赢
            break;
        }
    }
    for (int pick = 1; pick <= Math.min(b, m); pick++) {
        if (win1(a, b - pick, m).equals("后手")) {
            // 后续过程的赢家是后续过程的后手
            // 那就表示此时的先手，通过这个后续过程，能赢
            ans = "先手";
        }
        if (ans.equals("先手")) {
            break;
        }
    }
    dp[a][b][m] = ans;
    return ans;
}

// sg定理
public static String win2(int a, int b, int m) {
    int n = Math.max(a, b);
    int[] sg = new int[n + 1];
    boolean[] appear = new boolean[m + 1];
    for (int i = 1; i <= n; i++) {
        Arrays.fill(appear, false);
        for (int j = 1; j <= m && i - j >= 0; j++) {
            appear[sg[i - j]] = true;
        }
        for (int s = 0; s <= m; s++) {
            if (!appear[s]) {
                sg[i] = s;
                break;
            }
        }
    }
    return (sg[a] ^ sg[b]) != 0 ? "先手" : "后手";
}

// 时间复杂度O(1)的最优解
// 其实是根据方法2中的sg表观察出来的
public static String win3(int a, int b, int m) {
    return a % (m + 1) != b % (m + 1) ? "先手" : "后手";
}

题目4：三堆石头拿取斐波那契数博弈

有三堆石头，数量分别为a、b、c
两个人轮流拿，每次可以选择其中一堆石头，拿取斐波那契数的石头
拿到最后一颗石子的人获胜，根据a、b、c返回谁赢
来自真实大厂笔试，每堆石子的数量在10^5以内
没有在线测试，对数器验证

通过观察sg表，很难得到最简洁的结论，索性不优化了，反正数据量允许

package class096;

import java.util.Arrays;

// 三堆石头拿取斐波那契数博弈
// 有三堆石头，数量分别为a、b、c
// 两个人轮流拿，每次可以选择其中一堆石头，拿取斐波那契数的石头
// 拿到最后一颗石子的人获胜，根据a、b、c返回谁赢
// 来自真实大厂笔试，每堆石子的数量在10^5以内
// 没有在线测试，对数器验证
public class Code04_ThreeStonesPickFibonacci {

	// 如果MAXN变大
	// 相应的要修改f数组
	public static int MAXN = 201;

	// MAXN以内的斐波那契数
	public static int[] f = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 };

	public static String[][][] dp = new String[MAXN][MAXN][MAXN];

	// 动态规划方法彻底尝试
	// 为了验证
	public static String win1(int a, int b, int c) {
		// 假设当前的先手来行动
		// 注意不是全局的先手，是当前的先手来行动！
		// 当前！当前！当前！
		if (a + b + c == 0) {
			// 当前的先手，面对这个局面
			// 返回当前的后手赢
			return "后手";
		}
		if (dp[a][b][c] != null) {
			return dp[a][b][c];
		}
		String ans = "后手"; // ans : 赢的是当前的先手，还是当前的后手
		for (int i = 0; i < f.length; i++) {
			if (f[i] <= a) {
				if (win1(a - f[i], b, c).equals("后手")) {
					// 后续过程的赢家是后续过程的后手
					// 那就表示当前的先手，通过这个后续过程，能赢
					ans = "先手";
					break;
				}
			}
			if (f[i] <= b) {
				if (win1(a, b - f[i], c).equals("后手")) {
					// 后续过程的赢家是后续过程的后手
					// 那就表示当前的先手，通过这个后续过程，能赢
					ans = "先手";
					break;
				}
			}
			if (f[i] <= c) {
				if (win1(a, b, c - f[i]).equals("后手")) {
					// 后续过程的赢家是后续过程的后手
					// 那就表示当前的先手，通过这个后续过程，能赢
					ans = "先手";
					break;
				}
			}
		}
		dp[a][b][c] = ans;
		return ans;
	}

	// sg定理
	public static int[] sg = new int[MAXN];

	public static boolean[] appear = new boolean[MAXN];

	// O(10^5 * 24 * 2)
	public static void build() {
		for (int i = 1; i < MAXN; i++) {
			Arrays.fill(appear, false);
			for (int j = 0; j < f.length && i - f[j] >= 0; j++) {
				appear[sg[i - f[j]]] = true;
			}
			for (int s = 0; s < MAXN; s++) {
				if (!appear[s]) {
					sg[i] = s;
					break;
				}
			}
		}
	}

	public static String win2(int a, int b, int c) {
		return (sg[a] ^ sg[b] ^ sg[c]) != 0 ? "先手" : "后手";
	}

	public static void main(String[] args) {
		build();
		System.out.println("测试开始");
		for (int a = 0; a < MAXN; a++) {
			for (int b = 0; b < MAXN; b++) {
				for (int c = 0; c < MAXN; c++) {
					String ans1 = win1(a, b, c);
					String ans2 = win2(a, b, c);
					if (!ans1.equals(ans2)) {
						System.out.println("出错了！");
					}
				}
			}
		}
		System.out.println("测试结束");

		// 试图找到简洁规律，想通过O(1)的过程就得到sg(x)
		// 于是打印200以内的sg值，开始观察
		// 刚开始有规律，但是在sg(138)之后开始发生异常波动
		// 这道题在考的时候，数据量并没有大到需要O(1)的过程才能通过
		// 那就用build方法计算sg值，不再找寻简洁规律
		// 考试时一切根据题目数据量来决定是否继续优化
		for (int i = 0; i < MAXN; i++) {
			System.out.println("sg(" + i + ") : " + sg[i]);
		}
	}

}

题目5：E&D游戏

桌子上有2n堆石子，编号为1、2、3…2n
其中1、2为一组；3、4为一组；5、6为一组…2n-1、2n为一组
每组可以进行分割操作：
任取一堆石子，将其移走，然后分割同一组的另一堆石子
从中取出若干个石子放在被移走的位置，组成新的一堆
操作完成后，组内每堆的石子数必须保证大于0
显然，被分割的一堆的石子数至少要为2
两个人轮流进行分割操作，如果轮到某人进行操作时，所有堆的石子数均为1，判此人输掉比赛
返回先手能不能获胜
测试链接 : https://www.luogu.com.cn/problem/P2148

通过观察sg表，确实有最简洁的结论，但是也太难观察了吧！多练！以后遇到类似的就会了！

每一组的sg值：先打一小部分，观察规律，因为石子太多

(a-1)|(b-1)最低的0位置

package class096;

// 计算两堆石子的SG值
// 桌上有两堆石子，石头数量分别为a、b
// 任取一堆石子，将其移走，然后分割同一组的另一堆石子
// 从中取出若干个石子放在被移走的位置，组成新的一堆
// 操作完成后，组内每堆的石子数必须保证大于0
// 显然，被分割的一堆的石子数至少要为2
// 两个人轮流进行分割操作，如果轮到某人进行操作时，两堆石子数均为1，判此人输掉比赛
// 计算sg[a][b]的值并找到简洁规律
// 本文件仅为题目5打表找规律的代码
public class Code05_EDGame1 {

	public static int MAXN = 1001;

	public static int[][] dp = new int[MAXN][MAXN];

	public static void build() {
		for (int i = 0; i < MAXN; i++) {
			for (int j = 0; j < MAXN; j++) {
				dp[i][j] = -1;
			}
		}
	}

	public static int sg(int a, int b) {
		if (a == 1 && b == 1) {
			return 0;
		}
		if (dp[a][b] != -1) {
			return dp[a][b];
		}
		boolean[] appear = new boolean[Math.max(a, b) + 1];
		if (a > 1) {
			for (int l = 1, r = a - 1; l < a; l++, r--) {
				appear[sg(l, r)] = true;
			}
		}
		if (b > 1) {
			for (int l = 1, r = b - 1; l < b; l++, r--) {
				appear[sg(l, r)] = true;
			}
		}
		int ans = 0;
		for (int s = 0; s <= Math.max(a, b); s++) {
			if (!appear[s]) {
				ans = s;
				break;
			}
		}
		dp[a][b] = ans;
		return ans;
	}

	public static void f1() {
		System.out.println("石子数9以内所有组合的sg值");
		System.out.println();
		System.out.print("    ");
		for (int i = 1; i <= 9; i++) {
			System.out.print(i + " ");
		}
		System.out.println();
		System.out.println();
		for (int a = 1; a <= 9; a++) {
			System.out.print(a + "   ");
			for (int b = 1; b < a; b++) {
				System.out.print("X ");
			}
			for (int b = a; b <= 9; b++) {
				int sg = sg(a, b);
				System.out.print(sg + " ");
			}
			System.out.println();
		}
	}

	public static void f2() {
		System.out.println("石子数9以内所有组合的sg值，但是行列都-1");
		System.out.println();
		System.out.print("    ");
		for (int i = 0; i <= 8; i++) {
			System.out.print(i + " ");
		}
		System.out.println();
		System.out.println();
		for (int a = 1; a <= 9; a++) {
			System.out.print((a - 1) + "   ");
			for (int b = 1; b < a; b++) {
				System.out.print("X ");
			}
			for (int b = a; b <= 9; b++) {
				int sg = sg(a, b);
				System.out.print(sg + " ");
			}
			System.out.println();
		}
	}

	public static void f3() {
		System.out.println("测试开始");
		for (int a = 1; a < MAXN; a++) {
			for (int b = 1; b < MAXN; b++) {
				int sg1 = sg(a, b);
				int sg2 = lowZero((a - 1) | (b - 1));
				if (sg1 != sg2) {
					System.out.println("出错了!");
				}
			}
		}
		System.out.println("测试结束");
	}

	// 返回status最低位的0在第几位
	public static int lowZero(int status) {
		int cnt = 0;
		while (status > 0) {
			if ((status & 1) == 0) {
				break;
			}
			status >>= 1;
			cnt++;
		}
		return cnt;
	}

	public static void main(String[] args) {
		build();
		f1();
		System.out.println();
		System.out.println();
		f2();
		System.out.println();
		System.out.println();
		f3();
	}

}


package class096;

// E&D游戏
// 桌子上有2n堆石子，编号为1、2、3...2n
// 其中1、2为一组；3、4为一组；5、6为一组...2n-1、2n为一组
// 每组可以进行分割操作：
// 任取一堆石子，将其移走，然后分割同一组的另一堆石子
// 从中取出若干个石子放在被移走的位置，组成新的一堆
// 操作完成后，组内每堆的石子数必须保证大于0
// 显然，被分割的一堆的石子数至少要为2
// 两个人轮流进行分割操作，如果轮到某人进行操作时，所有堆的石子数均为1，判此人输掉比赛
// 返回先手能不能获胜
// 测试链接 : https://www.luogu.com.cn/problem/P2148
// 请同学们务必参考如下代码中关于输入、输出的处理
// 这是输入输出处理效率很高的写法
// 提交以下的code，提交时请把类名改成"Main"，可以直接通过

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Code05_EDGame2 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t = (int) in.nval;
		for (int i = 0; i < t; i++) {
			in.nextToken();
			int n = (int) in.nval;
			int sg = 0;
			for (int j = 1, a, b; j <= n; j += 2) {
				in.nextToken();
				a = (int) in.nval;
				in.nextToken();
				b = (int) in.nval;
				sg ^= lowZero((a - 1) | (b - 1));
			}
			if (sg != 0) {
				out.println("YES");
			} else {
				out.println("NO");
			}
		}
		out.flush();
		out.close();
		br.close();
	}

	public static int lowZero(int status) {
		int ans = 0;
		while (status > 0) {
			if ((status & 1) == 0) {
				break;
			}
			status >>= 1;
			ans++;
		}
		return ans;
	}

}
算法一——左程云
duanmy的博客
10-28 1279
题目一 认识时间复杂度 常数时间的操作 一个操作，如果和样本的数据量没有关系，每次都是固定时间内完成，叫做常数操作。 时间复杂度是一个算法流程中，常数操作数量的一个指标。常用O（读作big O）来表示。具体来说，先要对一个算法流程非常熟悉，然后去写出这个算法流程中，发生了多少常数操作，进而总结出常数操作数量的表达式。 在表达式中，只要高阶项，不要低阶项，也不要高阶项的系数，剩下的部分如果为f(N)，那么时间复杂度为O(f(N))。 评价一个算法流程的好坏，先看时间复杂度的指标，然后再分析不同数据样本下的实际
（左程云）算法讲解100【扩展】 KMP算法原理和代码详解
哀莫大于心死
05-07 492
假设已经有了next数组，详解匹配过程是如何得到加速的，加速过程有2个理解核心理解了匹配主流程之后，详解next数组如何快速生成，不停跳跃的过程有1个理解核心KMP算法代码详解，主流程 + next数组生成时间复杂度O(n)的证明，直接从代码层次就可以分析出来，分析方式好理解，但是比较特别我们图解一下，例子会很详细以后可以认为，求解1个位置的next数组的值，时间复杂度O(1)很多题目中都有next数组的使用，具体请看下期 - KMP算法相关题目。
（左程云）算法讲解052【必备】单调栈-上
哀莫大于心死
05-03 411
单调栈最经典的用法是解决如下问题：每个位置都求：0）当前位置的 左侧比当前位置的数字小，且距离最近的位置 在哪1）当前位置的 右侧比当前位置的数字小，且距离最近的位置 在哪或者每个位置都求：0）当前位置的 左侧比当前位置的数字大，且距离最近的位置 在哪1）当前位置的 右侧比当前位置的数字大，且距离最近的位置 在哪用单调栈的方式可以做到：求解过程中，单调栈所有调整的总代价为O(n)，单次操作的均摊代价为O(1)
左程云：程序员该如何学习算法？
编程喵叔
01-09 8434
大家好，我是左程云。我本科就读于华中科技大学、硕士毕业于在芝加哥大学。先后在IBM、百度、GrowingIO和亚马逊工作，是一个刷题7年的算法爱好者。 我是《程序员代码面试指南--IT名企算法与数据结构题目最优解》的作者 ，书籍涉及算法与数据结构编程题目240道以上，并且个人实现出最优解，大部分题目为面试高频。 这篇我想写写算法的重要性、我个人是如何学习算法以及一些如何学习算法
左程云数据结构与算法
云满笔记
09-27 557
1. 左程云数据结构与算法 1.1. 选择排序 选择排序的原理是，一个数组，0 ~ N-1，取一个最小的，把其位置与 0 位置进行交换。再是 1 ~ N-1 位置上取一个最小的，把其位置与 1 位置进行交换，如此反复。 时间复杂度计算: 看了: N + N-1 + N-2 + N-3 +... 比较了: N + N-1 + N-2 + N-3 +... 交换了: N 次 最终的结果必然是这种形式的: a * N ^ 2 + b * N + C。 ...
（左程云）算法讲解095【必备】博弈类问题必备内容详解-上
哀莫大于心死
05-08 769
情形3:那么如果有多堆石子>1呢?于是这就是常见的Nim游戏套路,将所有石子数异或起来后,情形2得到的值一定>0.因为>1的那一堆石子在二进制中除去末位一定还至少有一个1.所以说这时只要异或和>0就表示必胜.由于异或和为0的情况任意取都会变成异或和>0的情况,而异或和>0的情况一定有一种取石子方案使得异或和为0.那么异或和为0就表示了必败状态,而>0就表示必胜状态.,使得剩下的全部是1.而这两种操作后的局面一种是奇数个1,一种是偶数个1.所以先手一定可以留给后手奇数个1的局面,从而让后手必败,先手必胜.
左程云leetcode-algorithm-and-data-structure:算法+数据结构=程序
06-30
左程云leetcode 数据结构和算法学习笔记 一、简介 1. 2. 3. 4. 5. 6. 二、数据结构 1. 二维数组（Array2D） 位数组（Bit Set） 静态数组（Fixed Size Array） 有序表（Ordered Array） 2. 队列（Queues） （后进先出...
数据结构与算法 - 左程云相关内容
最新发布
07-29
左老师通过清晰的讲解，将复杂的算法原理转化为易懂的内容，结合实例分析，让抽象概念变得具体可感。 课程包含丰富的案例演示，通过实际问题的求解过程，展示算法与数据结构在解决问题时的应用方法。同时，注重培养...
左程云算法课笔记（1）
m0_61264859的博客
03-06 508
认识时间复杂度——常数时间操作 老师在这里拿数组和链表举例何为常数操作： 数组是一块连续的内存空间，当我们要访问数组中的某个元素时，我们可以算距离，怼偏移量，直接把这个数据拿出来，和样本的数据量，即数组的大小无关。当我们要访问链表中的某个元素时，由于链表在空间上是不连续的，我们只能通过指针挨个去看，例如有一个一百万的链表，当我们要访问其中十几万的元素，我们就要数十几万个，这个操作和数据量有关，不是常数操作。此外，加减乘除和位运算都为常数操作。 老师在这里拿数组排序来演示如何计算时间复
左程云算法初级课 在排好序的矩阵中找数问题 题目解析和代码实现 宏观调度问题
qq_40938077的博客
05-05 842
题目描述： 在已经排好序的矩阵中找出指定的数，并输出他在矩阵中的位置 排好序的矩阵： 从左到右，从上到下依次都是递增的。 基本思路： 设置一个点a，从数组的右上位置开始出发，通过比较a位置上的数和给定数的大小关系来确定a点接下来应该往哪个方向走。 如果a位置上的数大于给定的数，那么a应该往左走。假设用上图为例，假设给定的需要求的数是8，那么开始时a应该在13位置，13大于8，那么a...
class038 经典递归解析【算法】
小心星的博客
12-06 985
class038 经典递归解析【算法】
笔记 左程云算法基础
m0_58125693的博客
06-20 1906
归并排序比O(N^2)的排序好在哪：O(N^2)的排序每一轮的比较是独立的，一轮中有大量的比较，但只解决一个数。归并排序每一次的比较信息是往下传递的，变成了整体有序的部分继续去和其他部分merge，没有浪费比较行为。暴力求解：对每个i的左边都遍历一遍，O(n^2)深度改写mergesort思路：把问题变成——求右边有多少个数比i位置的数大，小和中就产生多少个i位置的数此问题中merge时左右组数值相等时，要先拷贝右侧数组中的数 题目-逆序对问题 相当于求右边有多少个数比i位置的数小..........
左程云老师算法课笔记（三）
njh1147394013的博客
10-07 631
算法笔记
左程云算法菜手班整理（一）
weixin_44683202的博客
05-02 947
新手班笔记
左程云算法-打表技巧
qy2016skq的博客
06-07 467
题目1： 小虎去买苹果，商店只提供两种类型的塑料袋，每种类型都有任意数量。 1）能装下6个苹果的袋子 2）能装下8个苹果的袋子 小虎可以自由使用两种袋子来装苹果，但是小虎有强迫症，他要求自己使用的袋子数量必须最少，且使用的每个袋子必须装满。 给定一个正整数N，返回至少使用多少袋子。如果N无法让使用的每个袋子必须装满，返回-1 代码地址：https://github.com/homesickjava/algorithm-zuochengyun/blob/master/AppleMinBags.java
左程云算法笔记（未完待续）
qq_53543658的博客
03-01 719
自学左程云老师算法课做的笔记
左程云算法笔记（持续更新）
qq_29763213的博客
11-13 1392
第一讲：时间复杂度与简单排序算法
左程云算法菜手班整理（二）
weixin_44683202的博客
05-04 332
左程云算法菜手班整理（二） 左程云算法新手班 2.1实现前缀和数组 求前缀和可以用前缀和矩阵和前缀和数组，但是前缀和矩阵预处理过程代价较大，所以一般用前缀和数组，但是去相应的值需要进行减法处理。 前缀和数组通过预处理，可以在o(1)复杂度的情况下得到前i~j位的和，称为数组。 #include<iostream> #include<vector> using namespace std; class NumArray { public: vector<int> su
（左程云）数据结构与算法（算法基础与经典排序算法）
weixin_52125363的博客
11-23 3984
提示：数据结构与算法入门版全套教程。 文章目录前言一、算法基础1.1 算法概念1.2 时间复杂度1.2.1 概念1.2.1 如何快速的判断算法的复杂度1.3 空间复杂度1.3.1 概念1.3.2 表示方式 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、算法基础 1.1 算法概念 算法（Algorithm）: 一个计算过程，解决问
左程云讲解算法与数据结构核心要点
资源摘要信息:"算法和数据结构——左程云" 1. 逻辑结构 逻辑结构主要涉及数据元素之间的关系，是抽象概念上的组织形式。逻辑结构可以分为以下几类： - 线性结构：这类结构中元素之间是一对一的关系，最常见的线性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值