22下第七周周赛补题

AcWing

第二题：矩阵

思路：把矩阵以字符串的形式存下来，把四次旋转的结果排序存下字典序最小的作为哈希值，最后哈希表的长度就是不同矩阵的个数。

#include<bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    unordered_set<string> hash;
    
    while(n--){
        string g[2],str;
        cin >> g[0]>>g[1]>>str; 
        
        int dx[]={0,0,1,1},dy[]={0,1,1,0}; //4个格子 左上 右上 左下  右下
        
        string s[4]; //把2X2的矩形以字符串的形式存储起来
        //发4种角度旋转后的字符串存入
        for(int i=0;i<4;i++){ //枚举位置
            for(int j=0;j<4;j++){ //偏移量
                int k=(i+j)%4;
                s[i]+=g[dx[k]][dy[k]];
            }
        }
        
        sort(s,s+4); //按字典序排序
        hash.insert(s[0]);  //把字典序最小的加入到集合   
    }
    
    cout<<hash.size()<<endl;
    return 0;
}

第三题：最短路程

思路：如图所示，每个点到达所有点的距离等于所有边距离的二倍减去起点到终点的距离，所以只需要找到距离起点最远的点即可。

 

 

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010, M = N * 2;

int n;
int h[N], e[M], w[M], ne[M], idx;

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dfs(int u, int fa)
{
    int res = 0;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa) continue; //防止掉头
        res = max(res, dfs(j, u) + w[i]);
    }

    return res;
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);

    LL sum = 0;
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
        add(b, a, c);
        sum += c * 2;
    }

    printf("%lld\n", sum - dfs(1, -1));

    return 0;
}

LeetCode单周赛

第四题：统计定界子数组的数目

思路：枚举子数组的右端点。遍历nums，记录minK上一次出现的位置minI和maxK上一次出现的位置maxI,当遍历到nums[i]时，如果minK和maxK之前出现过，则edge_i<=min(minI,maxI)的子数组都是合法的，合法子数组的个数为min(minI,maxI)+1

class Solution {
public:
    long long countSubarrays(vector<int> &nums, int min_k, int max_k) {
        long long ans = 0L;
        int n = nums.size(), min_i = -1, max_i = -1, edge_i = -1;
        for (int i = 0; i < n; ++i) {
            int x = nums[i];
            if (x == min_k) min_i = i;
            if (x == max_k) max_i = i;
            if (x < min_k || x > max_k) edge_i = i; // 子数组不能包含 nums[edge_i]
            ans += max(min(min_i, max_i) - edge_i, 0); //每遍历一个合法右边界 就加上最值较小的下标与左边界的差值
        }
        return ans;
    }
};