---

算法部分

1.Acwing 入门组每日一题
题目：画图
在一个定义了直角坐标系的纸上，画一个 (x1,y1) 到 (x2,y2) 的矩形指将横坐标范围从 x1 到 x2，纵坐标范围从 y1 到 y2 之间的区域涂上颜色。
下图给出了一个画了两个矩形的例子。
第一个矩形是 (1,1) 到 (4,4)，用绿色和紫色表示。
第二个矩形是 (2,3) 到 (6,5)，用蓝色和紫色表示。
图中，一共有 15 个单位的面积被涂上颜色，其中紫色部分被涂了两次，但在计算面积时只计算一次。
在实际的涂色过程中，所有的矩形都涂成统一的颜色，图中显示不同颜色仅为说明方便。

给出所有要画的矩形，请问总共有多少个单位的面积被涂上颜色。

输入格式
输入的第一行包含一个整数 n，表示要画的矩形的个数。
接下来 n 行，每行 4 个非负整数，分别表示要画的矩形的左下角的横坐标与纵坐标，以及右上角的横坐标与纵坐标。

输出格式
输出一个整数，表示有多少个单位的面积被涂上颜色。

数据范围
1≤n≤100,
0≤ 横坐标、纵坐标 ≤100

输入样例：
2
1 1 4 4
2 3 6 5
输出样例：
15

题解：
  本题数据较弱，可以使用模拟来求解，更好的解法是使用二维差分。

代码：

#include <iostream>

using namespace std;

const int MAXN = 110;
int g[MAXN][MAXN];

int main(){
    int n;
    int a, b, c, d;
    
    cin >> n;
    while(n --){
        cin >> a >> b >> c >> d;
        //防止下标0 越界
        a ++; b++; c ++; d ++;
        g[a][b] ++;
        g[a][d] --;
        g[c][b] --;
        g[c][d] ++;
    }
    
    int cnt = 0;
    for(int i = 1; i < MAXN; i ++)
        for(int j = 1; j < MAXN; j ++){
            g[i][j] += g[i - 1][j] + g[i][j - 1] - g[i - 1][j - 1];
            if(g[i][j])
                ++ cnt;
        }
    cout << cnt << endl;
    return 0;   
}

2.Acwing 提高组每日一题
题目：最优配餐
栋栋最近开了一家餐饮连锁店，提供外卖服务。
随着连锁店越来越多，怎么合理的给客户送餐成为了一个急需解决的问题。
栋栋的连锁店所在的区域可以看成是一个 n×n 的方格图（如下图所示），方格的格点上的位置上可能包含栋栋的分店（绿色标注）或者客户（蓝色标注），有一些格点是不能经过的（红色标注）。
方格图中的线表示可以行走的道路，相邻两个格点的距离为 1。
栋栋要送餐必须走可以行走的道路，而且不能经过红色标注的点。

送餐的主要成本体现在路上所花的时间，每一份餐每走一个单位的距离需要花费 1 块钱。
每个客户的需求都可以由栋栋的任意分店配送，每个分店没有配送总量的限制。
现在你得到了栋栋的客户的需求，请问在最优的送餐方式下，送这些餐需要花费多大的成本。

输入格式
输入的第一行包含四个整数 n,m,k,d，分别表示方格图的大小、栋栋的分店数量、客户的数量，以及不能经过的点的数量。
接下来 m 行，每行两个整数 xi,yi，表示栋栋的一个分店在方格图中的横坐标和纵坐标。
接下来 k 行，每行三个整数 xi,yi,ci，分别表示每个客户在方格图中的横坐标、纵坐标和订餐的量。（注意，可能有多个客户在方格图中的同一个位置）
接下来 d 行，每行两个整数，分别表示每个不能经过的点的横坐标和纵坐标。

输出格式
输出一个整数，表示最优送餐方式下所需要花费的成本。

数据范围
前 30% 的评测用例满足：1≤n≤20。
前 60% 的评测用例满足：1≤n≤100。
所有评测用例都满足：1≤n≤1000,1≤m,k,d≤n2。
可能有多个客户在同一个格点上。
每个客户的订餐量不超过 1000，每个客户所需要的餐都能被送到。

输入样例：
10 2 3 3
1 1
8 8
1 5 1
2 3 3
6 7 2
1 2
2 2
6 8
输出样例：
29

题解：
  挺好的图论BFS题，多源点bfs，框架模板题。

代码：

#include <iostream>
#include <queue>
#define ac cin.tie(0); cin.sync_with_stdio(0);
using namespace std;

const int MAXN = 1010;
long long dist[MAXN][MAXN], g[MAXN][MAXN];
int fx[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
int n, m, k, d;
typedef pair<int, int> PII;

int main(){
    ac
    queue<PII> Q;
    int a, b, c, cnt = 0;
    long long ans = 0;
    
    cin >> n >> m >> k >> d;
    
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n; j ++)
            dist[i][j] = -1;
    
    while(m --){
        cin >> a >> b;
        //将起点距离置为0，然后入队
        dist[a][b] = 0;
        Q.push(PII(a, b));
    }
    while(k --){
        cin >> a >> b >> c;
        //统计客户数量
        if(!g[a][b])
            ++ cnt;
        g[a][b] += c;
    }
    while(d --){
        cin >> a >> b;
        //标记障碍
        dist[a][b] = -2;
    }
    
    while(!Q.empty() && cnt){
        PII cur = Q.front();
        Q.pop();
        //四个方向扩展
        for(int i = 0; i < 4; i ++){
            int newr = cur.first + fx[i][0];
            int newc = cur.second + fx[i][1];
            //为访问过并且没有越界
            if(newr < 1 || newr > n || newc < 1 || newc > n || dist[newr][newc] != -1)
                continue;
            dist[newr][newc] = dist[cur.first][cur.second] + 1;
            //如果遇到了客户，则更新答案
            if(g[newr][newc]){
                ans += (long long)g[newr][newc] * dist[newr][newc];
                cnt --;
            }
            //新节点入队
            Q.push(PII(newr, newc));
        }
    }
    cout << ans << endl;
    return 0;
}

3.LeetCode 每日一题
题目：重塑矩阵
在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。
给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

示例 1:
输入:
nums =
[[1,2],
[3,4]]
r = 1, c = 4
输出:
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。

示例 2:
输入:
nums =
[[1,2],
[3,4]]
r = 2, c = 4
输出:
[[1,2],
[3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。

注意：
给定矩阵的宽和高范围在 [1, 100]。
给定的 r 和 c 都是正数。
通过次数45,079提交次数64,24

题解：
  先判断是否能转换，随后迭代生成新的矩阵。

代码：

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int m = nums.size();
        int n = nums[0].size();
        if (m * n != r * c) {
            return nums;
        }

        vector<vector<int>> ans(r, vector<int>(c));
        for (int x = 0; x < m * n; ++x) {
            ans[x / c][x % c] = nums[x / n][x % n];
        }
        return ans;
    }
};

4.矩阵置零
题目：
给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用原地算法。

示例 1:
输入:
[
[1,1,1],
[1,0,1],
[1,1,1]
]
输出:
[
[1,0,1],
[0,0,0],
[1,0,1]
]

示例 2:
输入:
[
[0,1,2,0],
[3,4,5,2],
[1,3,1,5]
]
输出:
[
[0,0,0,0],
[0,4,5,0],
[0,3,1,0]
]

进阶:
一个直接的解决方案是使用 O(mn) 的额外空间，但这并不是一个好的解决方案。
一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
你能想出一个常数空间的解决方案吗？

题解：
  难点在于不使用额外空间来求解，使用每列的第一个字符 和 每行的第一个字符作为标记，如果这一行有0，则置标记位为0，但是最左上角的字符会冲突，既代表第一行又代表第一列，所以规定左上角字符代表第一行，第一列使用额外bool 变量来记录，为 true代表第一列需要置0 。

代码：

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        bool op = false;

        for(int i = 0; i < matrix.size(); i ++){
        	//判断第一列
            if(!matrix[i][0])
                op = true;
            for(int j = 1; j < matrix[0].size(); j ++){
            	//更新每列每行的标记位
                if(!matrix[i][j])
                    matrix[i][0] = 0, matrix[0][j] = 0;
            }
        }
		//按照标记位来更新矩阵
        for(int i = matrix.size() - 1; i >= 0; i --){
            for(int j = matrix[0].size() - 1; j >= 0; j --){
                if(!matrix[i][0] || (j && !matrix[0][j]) || (!j && op))
                    matrix[i][j] = 0;
            }
        }
    }
};