第 102 场双周赛

6333.查询网格图中每一列的宽度

题意：
意思就是竖着来，看每列中变为字符串长度的最大值。首先我们要确定有多少列，就是看哪一行的元素数量最少。
然后就是遍历行，遍历列，转换为字符串，得长度，取最长压入。

#include
using namespace std;
class Solution {
public:
	vector<int> ans;
    vector<int> findColumnWidth(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = 101; 
        for(int i=0;i<m;i++){
        	if(grid[i].size() < n)  n = grid[i].size();
		}
		int num;
		string s;
		for(int i=0;i<n;i++){
		   num = -1;
  	    for(int j=0;j<m;j++){
			   s = to_string(grid[j][i]);
               //cout<<"s = "<
               int res = s.size();
               if(res > num) num = res;
		   }
		   ans.push_back(num);  
		}
		return ans;
    }
    
};

6334.一个数组所有前缀的分数

题意：意思就是给了一个转换数组的定义，conver[i] = arr[i] + max(arr[0…i])。而要我们返回的是ans，其中 ans[i]是前缀 nums[0…i] 的分数。就是转换数组的前缀和。

class Solution {
public:
	vector<long long> so;
	vector<long long> tran;
    vector<long long> findPrefixScore(vector<int>& nums) {
         long long l = nums.size();
		 //便利更新最大值
		 long long maxx = nums[0];
		 
		 tran.push_back(maxx + maxx);
		 
		 for(int i=1;i<l;i++){//转换数组 
		 	if(nums[i] > maxx){
		 	       maxx = nums[i];	
			}
			tran.push_back(nums[i] + maxx);
		 } 
        // for(int i=0;i
        //     cout<
        // }
        // cout<
		 so.push_back(tran[0]);
		 for(int i=1;i<l;i++){
		 	so.push_back(so[i-1] + tran[i]);
		 }
		 return so;
    }
};

6335.二叉树的堂兄弟节点 II

题意：意思就是计算所有堂兄弟节点值之和替代当前节点的值。因为根节点只有左右孩子没有根节点，所以置为0。
然后我们可以考虑用广度优先遍历来解决这个问题，每次遍历当前层的时候，我们可以计算下一层所有节点之和，随后我们对当前层进行二次遍历，遍历的过程中，计算每一个节点的亲兄弟的值，随后就是将当前节点的孩子的值都能替换成下一层节点总值和减去得亲兄弟值。

class Solution {
public:
    // 先计算当前节点的下一层节点所有值之和next_level_sum, 然后计算当前节点的两个孩子节点的值之和child_sum
    // 孩子节点的堂兄弟节点值的和为：next_level_sum-child_sum
    TreeNode* replaceValueInTree(TreeNode* root) {
        queue<TreeNode*> qu;//广度优先遍历
        qu.push(root);//根节点压入
        root->val=0;

        while(qu.size()){//遍历每一层
            int next_level_sum=0;//下一层的所有节点值之和
            int size=qu.size(); //当前层一共有几个
            vector<TreeNode*> tmp(qu.size(),nullptr);

            for(int i=0;i<size;i++){ //遍历当前层中每一个，
                TreeNode* node=qu.front();//取节点
                tmp[i]=node;//当前层节点放入tmp中
                qu.pop();
                if(node->left) {next_level_sum+=node->left->val;qu.push(node->left);}//如果有左子树，计算下一层节点总和，压入左节点
                if(node->right) {next_level_sum+=node->right->val;qu.push(node->right);}//如果有右子树，计算下一层节点总和，压入左节点
            }
            //再次遍历，两次遍历，对于当前层每一个节点，计算其左右孩子之和
            for(int i=0;i<tmp.size();i++){
                TreeNode* node=tmp[i];

                int child_sum=0;
                if(node->left) child_sum+=node->left->val;//例如第二层，其为亲兄弟，所以都加上了，如此一减等于0
                if(node->right) child_sum+=node->right->val;

                if(node->left){
                    node->left->val=next_level_sum-child_sum;
                }
                if(node->right){
                    node->right->val=next_level_sum-child_sum;
                }
            }

        }
        return root;
    }
};

2642.设计可以求最短路径的图类

题意：其实就是一个最短路算法，其包括建图，插入边，求单源最短路。

typedef long long LL;
const int N = 110;
const LL INF = 1e12;
LL dist[N], g[N][N];
bool vis[N];

class Graph {
public:
    int n;
    Graph(int n, vector<vector<int>>& edges) {
        this->n = n;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                g[i][j] = INF;
                if(i == j) g[i][j] = 0;
            }
        }
        for(auto e: edges) {
            int a = e[0], b = e[1], w = e[2];
            g[a][b] = w;
        }
    }
    
    void addEdge(vector<int> edge) {
        int a = edge[0], b = edge[1], w = edge[2];
        g[a][b] = w;
    }
    
    int shortestPath(int src, int dest) {
        for(int i = 0; i < n; i++) {
            vis[i] = false;
            dist[i] = INF;
        }
        dist[src] = 0;
        for(int i = 0; i < n; i++) {
            int t = -1;
            for(int j = 0; j < n; j++) {
                if(!vis[j] && (t == -1 || dist[j] < dist[t])) {
                    t = j;
                }
            }
            vis[t] = true;
            for(int j = 0; j < n; j++) {
                dist[j] = min(dist[j], dist[t] + g[t][j]);
            }
        }
        return dist[dest] == INF? -1: dist[dest];
    }

};