第 300 场周赛题解

解密消息

看清题意后模拟，可以用一个哈希表存放a-z每个字母的对应关系（当然直接用char数组也行），遍历message，遇到一个小写字母就转换为对照表中它对应的字母加到解密字符串中，遇到空格直接加到解密字符串中。

class Solution {
public:
    map<char,char>mp;
    string decodeMessage(string key, string message) {
        int j=0;
        char ch='a';
        for(int i=0;i<key.size();i++){
            if(key[i]==' ')
                continue;
            if(mp[key[i]]>='a')
                continue;
           mp[key[i]]=ch;
            ch++;
        }
        string res;
        for(int i=0;i<message.size();i++){
            if(message[i]==' ')
                res+=" ";
            else
                res+=mp[message[i]];
        }
        return res;
    }
};

螺旋矩阵 IV

首先声明一个m*n的二维vector数组，并且数组中的每个元素全初始化为-1。从矩阵左上角出发，顺时针按螺旋顺序填充，由于链表head中没有-1，因此填充过的数组的值一定不为-1，那么剩下的未填充的元素就是-1了。遍历链表，将链表中的值填充到矩阵中，然后移动到下一个位置继续填充，移动的方向一定是右->下->左->上->右…这种顺序，在四个方向尝试移动，如果出界或者下一个位置被填充过则无法移动。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
        vector<vector<int>>res(m,vector<int>(n,-1));
        int t=0,i=0,j=0;
        while(head!=NULL){
            res[i][j]=head->val;
            head=head->next;
            if(head==NULL)
                break;
            int d;
            for(int k=0;k<4;k++){
                d=(t+k)%4;
                if(d==0&&j+1<n&&res[i][j+1]==-1){
                    j++;    t=d;
                    break;
                }
                else if(d==1&&i+1<m&&res[i+1][j]==-1){
                    i++;    t=d;
                    break;
                }
                else if(d==2&&j-1>=0&&res[i][j-1]==-1){
                    j--;    t=d;
                    break;
                }
                else if(d==3&&i-1>=0&&res[i-1][j]==-1){
                    i--;    t=d;
                    break;
                }
            }
        }
        return res;
    }
};

知道秘密的人数

看懂样例，寻找递推关系。
将知道过秘密的总人数减去已经忘记秘密的人数就是当前知道秘密的人数。注意取模操作要加上模数。

class Solution {
public:
    int mod=1e9+7,forgetnum;
    long long a[1010],b[1010];
    int peopleAwareOfSecret(int n, int delay, int forget) {
        a[0]=1;
        for(int i=1;i<=n;i++){
            a[i]=a[i-1];
            forgetnum=0;
            if(i>forget)
            forgetnum=a[i-forget];
            if(i>delay)
            a[i]=(a[i]-forgetnum+a[i-delay]+mod)%mod;
            
        }
        return (a[n]-forgetnum+mod)%mod;
    }
};

网格图中递增路径的数目

记忆化搜索，记录以某个点为起点，该点可以走的所有递增路径的个数。

class Solution {
public:
    int m,n,mod=1e9+7,f[1010][1010];
    int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
    int dfs(int x,int y,vector<vector<int>>& grid){
        if(f[x][y]!=-1)
            return f[x][y];
        f[x][y]=1;
        int tx,ty;
        for(int i=0;i<4;i++){
            tx=dir[i][0]+x;
            ty=dir[i][1]+y;
            if(tx<0||tx>=m||ty<0||ty>=n||grid[tx][ty]<=grid[x][y])
                continue;
            f[x][y]=(f[x][y]+dfs(tx,ty,grid))%mod;
        }
        return f[x][y];
    }
    int countPaths(vector<vector<int>>& grid) {
        m=grid.size();
        n=grid[0].size();
        memset(f,-1,sizeof(f));
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                dfs(i,j,grid);
            }
        }
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
              res=(res+f[i][j])%mod;
            }
        }
        return res;
    }
};