春招实习|美团0323_小美拿到一个n行m列的矩阵,计算矩阵中有多少个2*2的子矩阵满足0和1个数相等

前言

美团0323策略算法笔试

一

n行m列的矩阵，求多少个2*2的子矩阵满足0和1的数量相等。

思路：左上角开始遍历，求子矩阵内元素所有元素的和。
注：注意输入数据类型，这里矩阵输入为字符串

#include<iostream>
#include <vector>
using namespace std;
int main(){
    int n,m;
    cin>>n>>m;
    vector<vector<int>> array(n,vector(m,0));
    for(int i =0;i<n;i++){
        string str;
        cin>>str;
        for(int j = 0 ; j<m;j++){
            array[i][j]=str[j]-'0';
        }
    }
    int ans = 0;
    for(int i =0;i<n-1;i++){
        for(int j =0;j<m-1;j++){
            if(array[i][j]+array[i+1][j]+array[i][j+1]+array[i+1][j+1]==2){
                ans++;
            }
        }
    }
    cout<<ans<<endl;
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

二

一个长为n的字符串s，尽可能删除少的m个字符，使得字符串不含长度为偶数的回文子串，求m
思路：考虑回文偶数子串，**当有连续三个及以上的字符出现时，必会出现长度2的回文子串。**故仅需保证删除后字符串中不含有连续一样的字符即可。

#include<iostream>
#include <vector>
#include <string>


using namespace std;

int main(){
    int length;
    cin>>length;
    string str;
    cin>>str;
    char rembChar;
    char nowChar='0';
    int ans=0;
    for(int i =0;i<length;i++){
        nowChar=str[i];
        if(rembChar!=nowChar){
            rembChar = nowChar;
        }
        else{
            ans++;
        }
    }
    cout<<ans<<endl;
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

三

一个排列，该排列由1-n共n个数字组成，有些数字对应白色W，有些对应红色R，红色的数字允许被交换，问最少经过多少次交换可以使该排列变为非降序排列。
思路；非降序排列且排列数组由1-n组成，即排列后需变为1-n的升序顺序数组，故每个数字的位置与该数字相同。考虑能否通过交换实现则仅需考虑白色位置的数字与其位置是否已经对应，若不对应则无法通过交换实现
如
1324
WRRW
可以实现

1324
WWRR
则不能实现

注：思路转化为求不在自己位置上可交换数字升序排序的最小交换次数，可以使用原地哈希求解最小排序次数。

#include<iostream>
#include <vector>
using namespace std;

int main(){
    int n;
    cin>>n;
    vector<int> array(n+1);
    vector<int> ischange(n+1);
    vector<int> hash(n+1);
    for(int i =1;i<n+1;i++){
        cin>>array[i];
    }

    string color;
    cin>>color;

    for(int i =1;i<n+1;i++){
        if(array[i]!=i&&color[i-1]=='W'){
            cout<<-1<<endl;            
            system("pause");
            return 0;
        }
        else if(array[i]!=i&&color[i-1]=='R'){
            hash[array[i]]=i;
            ischange[array[i]]=1;
        }
    }
    
    int ans=0;
    for(int i = 1;i<n+1;i++){
        if(ischange[i]==1){
            int rem=hash[i];
            int nownum=hash[hash[i]];
            while(nownum!=rem){
                nownum=hash[nownum];
                ans++;
                ischange[nownum]=0;
            }
        }

    }
    
    cout<<ans<<endl;
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

四

定义一个字符串的权值为字符串长度乘以总类数
对于一个字符串，将他切割为若干个连续子串，使得每个子串的权值不小于k。求最多可以切割的子串数量

思路：考虑到顺序固定且子串连续，不存在权重值过大之后需要重规划的问题。故只需要考虑当目前子串权重值符合要求后切割子串即可
可以使用pair数组存储给定字符串，通过比较当前字母所用的次数与pair.second的大小决定是否需要添加新字母。循环n次时需注意，为保证所有字符均遍历一遍，要在无次数+1的情况下增加循环次数，如改变当前字母以及当前权重符合条件进行更新时。

#include<iostream>
#include <vector>
#include <set>
using namespace std;

int main(){
    long n=12, k=5;
    // cin>>n>>k;
    string str="a(2)b(2)a(3)c(5)";
    // cin>>str;
    char nowChar, nowLetter;
    int nowTimes=0;
    bool flag = 0;
    vector< pair<char,int> > init_array;
    for(int i = 0 ; i<str.length();i++){
        nowChar = str[i];
        if(nowChar>='a'&&nowChar<='z'){
            nowLetter=nowChar;
        }
        else if(nowChar=='('){
            flag = 1;
        }

        if(flag==1){
            if(nowChar>='0'&&nowChar<='9'){
                nowTimes =nowTimes*10+nowChar-'0';
            }
            else if(nowChar==')'){
                init_array.push_back(pair<char,int>(nowLetter, nowTimes));
                flag = 0 ;
                nowTimes = 0;
            }
        }
    }

    int lettersType = 0 ;
    int lettersLength = 0;
    int nowLetterUseTimes = 0;
    set<char> s;
    int j=0;
    int ans = 0;
    for(long i=0;i<n;i++){
        if(lettersType*lettersLength<k){
            if(s.count(init_array[j].first)==0){
                s.insert(init_array[j].first);
                lettersType++;
            }
            if(nowLetterUseTimes==init_array[j].second){
                j++;
                i--;
                nowLetterUseTimes=0;
            }
            else if(nowLetterUseTimes<init_array[j].second){
                nowLetterUseTimes++;
                lettersLength++;
                cout<<init_array[j].first;
            }
        }
        else{
            ans++;
            lettersLength = 0;
            lettersType = 0 ;
            i--;
            s.erase(s.begin(),s.end());
        }
    }
    if(lettersType*lettersLength>=k){
        ans++;
    }
    
    cout<<ans<<endl;
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74