日常算法模板

目录：

• 二分搜索
• 矩阵快速幂
• 前缀和
• 差分数组

二分搜索模板

while里都是 <= 号注定了 left有+1 和 right有-1
第一段代码查到即返回；
第二段代码要查找的是最左边的target；
第三段代码要查找的是最右边的target。
代码自己终止的条件是 ] [ ，知道这个就知道第二、三段代码怎么返回了。

int binary_search(int[] nums, int target) {
    int left = 0, right = nums.length - 1; 
    while(left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1; 
        } else if(nums[mid] == target) {
            // 直接返回
            return mid;
        }
    }
    // 直接返回
    return -1;
}

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 判断 target 是否存在于 nums 中
    // 此时 target 比所有数都大，返回 -1
    if (left == nums.length) return -1;
    // 判断一下 nums[left] 是不是 target
    return nums[left] == target ? left : -1;
}

int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定右侧边界
            left = mid + 1;
        }
    }
    // 此时 left - 1 索引越界，可以改为 right
    if (left - 1 < 0) return -1;
    // 判断一下 nums[left] 是不是 target
    return nums[left - 1] == target ? (left - 1) : -1;
}

我经常有这么疑问，为什么返回前要等值判断一下？
因为在搜索结束后 ] [ 可能停留在数组中间的位置。
举例在 [ 5(right)，7(left)，7，8，8，10] 中找 6 。

重点：要知道，如果最后没找到目标值，那么“ ] ”左边的是比目标值小的，“ [ ”右边的是比目标值大的。

矩阵快速幂

#include<bits/stdc++.h>
using namespace std;
class Rec {
public:
	int** rec;
	int m;
	Rec(int m) {
		rec = new int* [m];
		for (int i = 0; i < m; i++) {
			rec[i] = new int[m];
			fill_n(rec[i], m, 0);
			// 或者用 memset(rec[i], 0, sizeof(int) * m);
		}
		this->m = m;
	}
	void initialize() {
		for (int i = 0; i < m; i++)
			for (int j = 0; j < m; j++)
				cin >> rec[i][j];
	}
	void print() {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < m; j++) {
				cout << rec[i][j] << " ";
			}
			cout << endl;
		}
	}
};
Rec mul(Rec a, Rec b,int m) {
	Rec c(m);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < m; j++) {
			for (int k = 0; k < m; k++) {
				c.rec[i][j] += a.rec[i][k] * b.rec[k][j];
			}
		}
	}
	return c;
}
int main() {
	cout << "几维方针？几次幂？" << endl;;
	int m, n;
	cin >> m >> n;;
	Rec a(m);
	cout << "初始化方针：" << endl;
	a.initialize();
	Rec res(m);
	// res是一个单位阵
	for (int i = 0; i < m; i++) {
		res.rec[i][i] = 1;
	}
	while (n > 1) {
		if (n % 2 == 1) {
			res = mul(res, a, m);
		}
		a = mul(a, a, m);
		n >>= 1;
	}
	res = mul(res, a, m);
	cout << "计算结果如下：" << endl;
	res.print();
	return 0;
}

运行结果如下：

前缀和

前缀和主要适用的场景是原始数组不会被修改的情况下，频繁查询某个区间的累加和。

class PrefixSum {
    // 前缀和数组
    private int[] prefix;
    
    /* 输入j一个数组，构造前缀和 */
    public PrefixSum(int[] nums) {
        prefix = new int[nums.length + 1];
        // 计算 nums 的累加和
        for (int i = 1; i < prefix.length; i++) {
            prefix[i] = prefix[i - 1] + nums[i - 1];
        }
    }

    /* 查询闭区间 [i, j] 的累加和 */
    public int query(int i, int j) {
        // prefix[i] 就代表着 nums[0..i-1] 所有元素的累加和
        // 如果我们想求区间 nums[i..j] 的累加和，只要计算 prefix[j+1] - prefix[i] 即可
        return prefix[j + 1] - prefix[i]; 
    }
}

差分数组

主要适用场景是频繁对原始数组的某个区间的元素进行增减。

• 比如说，我给你输入一个数组 nums，然后又要求给区间 nums[2…6] 全部加 1，再给 nums[3…9] 全部减 3，再给 nums[0…4] 全部加 2，再给…一通操作猛如虎，然后问你，最后 nums 数组的值是什么？

• 常规的思路很容易，你让我给区间 nums[i…j] 加上 val，那我就一个 for 循环给它们都加上呗，还能咋样？这种思路的时间复杂度是 O(N)，由于这个场景下对 nums 的修改非常频繁，所以效率会很低下。

class Difference {
    // 差分数组
    private:
        int* diff;
        int length;
    /* 输入一个初始数组，区间操作将在这个数组上进行 */
    public:
        Difference(int* nums, int length) {
            this->length = length;
            diff = new int[length];
            diff[0] = nums[0];
            for (int i = 1; i < length; i++) {
                diff[i] = nums[i] - nums[i - 1];
            }
        }

        /* 给闭区间 [i, j] 增加 val（可以是负数）*/
        void increment(int i, int j, int val) {
            diff[i] += val;
            if (j + 1 < length) {
                diff[j + 1] -= val;
            }
        }

        /* 返回结果数组 */
        int* result() {
            int* res = new int[length];
            res[0] = diff[0];
            for (int i = 1; i < length; i++) {
                res[i] = res[i - 1] + diff[i];
            }
            return res;
        }
};

• 如果你想对区间 nums[i…j] 的元素全部加 3，那么只需要让 diff[i] += 3，然后再让 diff[j+1] -= 3 。
• 原理很简单，回想 diff 数组反推 nums 数组的过程，diff[i] += 3 意味着给 nums[i…] 所有的元素都加了 3，然后 diff[j+1] -= 3 又意味着对于 nums[j+1…] 所有元素再减 3，那综合起来，是不是就是对 nums[i…j] 中的所有元素都加 3 了