2021-06-18

输入：words = ["smooth","common","moorings"]
输出："moo"，其他如 "omo", "oom" 也是正确答案。
解释：
m 在 "smooth" 中出现 1 次，在 "common" 中出现 2 次，在 "moorings" 中出现 1 次，所以只有 1 个 m 符合要求。
o 在 "smooth" 中出现 2 次，在 "common" 中出现 2 次，在 "moorings" 中出现 2 次，所以 2 个 o 均符合要求。
其他字符没有在 words 的每个字符串中都出现。

输入：words = ["software"]
输出："software"，其他如 "waresoft", "aeforstw" 等也是正确答案。

class Solution {
public:
string SharedLetters(const vector<string>& words)
{
string result;

int size1 = words.size();
int size2 = 0;

vector<vector<int>> vec(size1, vector<int>());//初始层数，赋值
for (int i = 0; i < size1; i++) {
vec[i].resize(26);
}

 

for (int i = 0; i < size1; ++i) {
size2 = words[i].length();
for (int j = 0; j < size2; j++) {
vec[i][words[i][j] - 'a']++;
}
}

int tmp = 0;

for (int i = 0; i < 26; i++) {

tmp = INT32_MAX;
for (int j = 0; j < size1; j++) {
tmp = min(tmp, vec[j][i]);
}
while (tmp != 0) {
result.push_back('a' + i);
tmp--;
}

}

return result;

}
};

 

int main()
{
Solution solution;

//string words[] = {"smooth","common","moorings"};
vector<string> words{"smooth","common","moorings"};
cout<<solution.SharedLetters(words);
}

 

 

某个系统中有一空间连续的内存，被划分成多个大小相同的内存块，内存的使用状态记录在字符串memory中，每个内存块的状态用x或者.表示，

其中.表示该内存块空闲

x表示该内存块被使用，x为小写字母。

 

现在可释放其中最多cnt个内存块，即x变成.，以获得一块空间连续的，且最长的空闲内存，请计算并返回该最长空间内存的内存块数量。

 

/*

 * 算法逻辑：把每个x位置记录到一个数组，只需要统计cnt连续元素的差即可

 * 已知字符串前面加上*后面加上*不改变结果，数组前面加上-1，后面加上字符串长度。

 * 需要检查两个边界

 * 1. cnt为零时，只需要统计现在的数组的相邻差即可

 * 2. x元素个数小于等于cnt时候，只需要统计字符串长度即可

 */

class Solution {

public:

    int GetMaxFreeMemoryLen(string memory, int cnt) {

        int result = 0;

        int size1 = memory.length();

 

        vector<int> xp;

        xp.push_back(-1);

 

        for (int i = 0; i < size1; i++) {

            if (memory[i] == 'x') {

                xp.push_back(i);

            }

        }

        xp.push_back(size1);

 

        int size2 = xp.size();

 

        if (cnt <= 0) {

            for (int i = 1; i < size2; i++) {

                result = max(result, xp[i] - xp[i - 1] - 1);

            }

            return result;

        }

 

        if (size2 <= cnt + 2) {

            return size1;

        }

 

        for (int i = cnt + 1; i < size2; i++) {

            result = max(result, xp[i] - xp[i - cnt - 1] - 1);

        }

        return result;

    }

};

 

 

 

第二题目，通过 8ms 9.2M

 

专业级

 

"""
某仓库墙边有一排货箱，按从左致右的顺序把每个货箱的重量记录在数组boxes中
管理员需要整理所有货箱，要求如下：
1.将若干位置连续的货箱堆起，从左-->右分成三堆，每一堆至少有一个货箱
2.三堆重量 1 <=2 <=3
问，有几种可行的方法

例：boxes = [1,1,2,1,4] 有5种
boxes = [3,2,3] 有0种
"""

class Solution {
public:
    int get_result(vector<int> & boxes)
    {
        int result = 0;

        int size1 = boxes.size();
        if (size1 <= 3) {
            return 0;
        }

        vector<int> sum(size1 + 1);
        sum[0] = 0;

        int tmp = 0;
        for (int i = 0; i <size1; ++i) {
            tmp += boxes[i];
            sum[i + 1] = tmp;
        }

        for (int left = 1; left <= size1 - 1; left++) {
            for (int right = left + 1; right <= size1; right++) {
                if (sum[right] - sum[left] > sum[size1] - sum[right]) {
                    break;
                }
                if (sum[right] - sum[left] >= sum[left] - sum[0]) {
                    result++;
                }
            }
        }

        return result;
    }
};


int main ()
{

    vector<int> boxes {1,1,2,1,4,5};
    //vector<int> boxes {3,2,3};
    Solution s;
    cout<<s.get_result(boxes);

}