leetcode405周赛

100339. 找出加密后的字符串

给你一个字符串 s 和一个整数 k。请你使用以下算法加密字符串：

• 对于字符串 s 中的每个字符 c，用字符串中 c 后面的第 k 个字符替换 c（以循环方式）。
• 

class Solution {
public:
    string getEncryptedString(string s, int k) {
        int len = s.size();
        string res = "";
        for(int i = 0; i < len;  i++){
            res += s[(i + k ) % len];
        }
        return res;
    }
};

100328. 生成不含相邻零的二进制字符串

给你一个正整数 n。

如果一个二进制字符串 x 的所有长度为 2 的

子字符串

中包含 至少 一个 "1"，则称 x 是一个 有效 字符串。

返回所有长度为 n 的 有效 字符串，可以以任意顺序排列。

 

class Solution {
public:
    vector<string> res;

    void dfs(int n, string s){
        if(s.size() == n){
            res.push_back(s);
            return;
        }
        dfs(n, s + '1');
        if(s[s.size() - 1] == '1')
            dfs(n, s + '0');
    }

    vector<string> validStrings(int n) {
        dfs(n, "0");
        dfs(n, "1");
        return res;
    }
};

 100359. 统计 X 和 Y 频数相等的子矩阵数量

给你一个二维字符矩阵 grid，其中 grid[i][j] 可能是 'X'、'Y' 或 '.'，返回满足以下条件的

子矩阵

数量：

• 包含 grid[0][0]
• 'X' 和 'Y' 的频数相等。
• 至少包含一个 'X'。

 

class Solution {
public:
    
    int numberOfSubmatrices(vector<vector<char>>& grid) {
        int len1 = grid.size();
        int len2 = grid[0].size();
        vector<vector<pair<int, int>>> sum(len1 + 1, vector<pair<int, int>>(len2 + 1, {0, 0}));
        int res = 0;

        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                sum[i][j].first = sum[i - 1][j].first + sum[i][j - 1].first - sum[i - 1][j - 1].first + (grid[i - 1][j - 1] == 'X' ? 1 : 0);
                sum[i][j].second = sum[i - 1][j].second + sum[i][j - 1].second - sum[i - 1][j - 1].second + (grid[i - 1][j - 1] == 'Y' ? 1 : 0);
                int totalX = sum[i][j].first;
                int totalY = sum[i][j].second;
                if (totalX == totalY && totalX)
                    res++;
            }
        }

        return res;
    }
};

100350. 最小代价构造字符串

给你一个字符串 target、一个字符串数组 words 以及一个整数数组 costs，这两个数组长度相同。

设想一个空字符串 s。

你可以执行以下操作任意次数（包括零次）：

• 选择一个在范围  [0, words.length - 1] 的索引 i。
• 将 words[i] 追加到 s。
• 该操作的成本是 costs[i]。

返回使 s 等于 target 的 最小 成本。如果不可能，返回 -1。

 

struct node
{
    int lv;
    int pre;
    int cost;
    int childs[26];
};
node tree[50001];
int ncnt;
int dp[50000];
int st,en;
int q[50000];
void initnode(int index)
{
    tree[index].lv=-1;
    tree[index].pre=-1;
    tree[index].cost=-1;
    for(int i=0;i<26;i++)
        tree[index].childs[i]=-1;
}
void insert(string &s,int cost)
{
    int root=0;
    for(int i=0;i<s.length();i++)
    {
        if(tree[root].childs[s[i]-'a']==-1)
        {
            initnode(ncnt);
            tree[root].childs[s[i]-'a']=ncnt++;
        }
        root=tree[root].childs[s[i]-'a'];
    }
    tree[root].lv=s.length();
    if(tree[root].cost==-1||tree[root].cost>cost)
    tree[root].cost=cost;
}
void initpre()
{
    st=0;
    en=0;
    q[en++]=0;
    while(st<en)
    {
        int node=q[st++];
        for(int i=0;i<26;i++)
        if(tree[node].childs[i]!=-1)
        {
            int pre=tree[node].pre;
            while(pre!=-1&&tree[pre].childs[i]==-1)
                pre=tree[pre].pre;
            if(pre==-1)
                tree[tree[node].childs[i]].pre=0;
            else
                tree[tree[node].childs[i]].pre=tree[pre].childs[i];
            q[en++]=tree[node].childs[i];
        }
    }
}
void work(string &s)
{
    int root=0;
    for(int i=0;i<s.length();i++)
    {
        while(root!=-1&&tree[root].childs[s[i]-'a']==-1)
            root=tree[root].pre;
        if(root==-1)
            root=0;
        else
            root=tree[root].childs[s[i]-'a'];
        int tmp=root;
        dp[i]=-1;
        while(tmp!=-1)
        {
            if(tree[tmp].cost!=-1)
            {
                int nex=tree[tmp].cost;
                if(i-tree[tmp].lv==-1||dp[i-tree[tmp].lv]!=-1)
                {
                    if(i-tree[tmp].lv!=-1)
                        nex+=dp[i-tree[tmp].lv];
                    if(dp[i]==-1||dp[i]>nex)
                        dp[i]=nex;
                }
            }
            tmp=tree[tmp].pre;
        }
    }
}
class Solution {
public:
    int minimumCost(string target, vector<string>& words, vector<int>& costs) {
        initnode(0);
        ncnt=1;
        for(int i=0;i<words.size();i++)
            insert(words[i],costs[i]);
        initpre();
        work(target);
        return dp[target.length()-1];
    }
};