【模拟面试】#3 删除子文件夹 行相等的最少多米诺旋转 打乱数组

题目1

你是一位系统管理员，手里有一份文件夹列表 folder，你的任务是要删除该列表中的所有 子文件夹，并以 任意顺序 返回剩下的文件夹。

我们这样定义「子文件夹」：

• 如果文件夹 folder[i] 位于另一个文件夹 folder[j] 下，那么 folder[i] 就是 folder[j] 的子文件夹。

文件夹的「路径」是由一个或多个按以下格式串联形成的字符串：

• / 后跟一个或者多个小写英文字母。

例如，/leetcode 和 /leetcode/problems 都是有效的路径，而空字符串和 / 不是。

 

示例 1：

输入：folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
输出：["/a","/c/d","/c/f"]
解释："/a/b/" 是 "/a" 的子文件夹，而 "/c/d/e" 是 "/c/d" 的子文件夹。

示例 2：

输入：folder = ["/a","/a/b/c","/a/b/d"]
输出：["/a"]
解释：文件夹 "/a/b/c" 和 "/a/b/d/" 都会被删除，因为它们都是 "/a" 的子文件夹。

示例 3：

输入：folder = ["/a/b/c","/a/b/d","/a/b/ca"]
输出：["/a/b/c","/a/b/ca","/a/b/d"]

 

提示：

• 1 <= folder.length <= 4 * 10^4
• 2 <= folder[i].length <= 100
• folder[i] 只包含小写字母和 /
• folder[i] 总是以字符 / 起始
• 每个文件夹名都是唯一的

思路及代码

先按照字母序排序，这样每两个之间就有可比性了，然后就是通过find()来查找是否包含子串，为了区别/A/B和/A/BC这样的区别，就在前一个要比较的后面加个/就行了。

class Solution {
public:
    vector<string> removeSubfolders(vector<string>& folder) {
        sort(folder.begin(),folder.end());
        vector<string> ans;

        ans.push_back(folder[0]);

        for(int i = 1;i < folder.size();i++){
            //前一个最后加/以防止类似a/b与a/bc的区别
            string father = ans.back()+'/';
            string cur = folder[i];

            //npos:npos 是一个常数，用来表示不存在的位置
            if(cur.find(father)==cur.npos)
                ans.push_back(cur);
        }

        return ans;

    }
};

题目2

在一排多米诺骨牌中，A[i] 和 B[i] 分别代表第 i 个多米诺骨牌的上半部分和下半部分。（一个多米诺是两个从 1 到 6 的数字同列平铺形成的 —— 该平铺的每一半上都有一个数字。）

我们可以旋转第 i 张多米诺，使得 A[i] 和 B[i] 的值交换。

返回能使 A 中所有值或者 B 中所有值都相同的最小旋转次数。

如果无法做到，返回 -1.

 

示例 1：

输入：A = [2,1,2,4,2,2], B = [5,2,6,2,3,2]
输出：2
解释：
图一表示：在我们旋转之前， A 和 B 给出的多米诺牌。
如果我们旋转第二个和第四个多米诺骨牌，我们可以使上面一行中的每个值都等于 2，如图二所示。

示例 2：

输入：A = [3,5,1,2,3], B = [3,6,3,3,4]
输出：-1
解释：
在这种情况下，不可能旋转多米诺牌使一行的值相等。

 

提示：

1. 1 <= A[i], B[i] <= 6
2. 2 <= A.length == B.length <= 20000

思路及代码

首先对上下两排的各个数字的出现情况进行统计，然后结果从大到小排序，比较该情况中是否能让数字全部一样，A和B各比一次取最小，即答案。

class Solution {
public:

    vector<pair<int, int>> vc;
    vector<pair<int, int>>::iterator vit;

    static bool cmp(pair<int, int> a, pair<int, int> b) {
	    return a.second < b.second;
    }   

    int minDominoRotations(vector<int>& A, vector<int>& B) {
        map<int,int> num_a;
        map<int,int> num_b;
        int len = A.size();

        num_a[1] = 0;num_a[2] = 0;num_a[3] = 0;num_a[4] = 0;num_a[5] = 0;num_a[6] = 0;
        num_b[1] = 0;num_b[2] = 0;num_b[3] = 0;num_b[4] = 0;num_b[5] = 0;num_b[6] = 0;

        for(int i = 0;i < len;i++){
            num_a[A[i]]++;
            num_b[B[i]]++;
        }

        int minres = -1;

        for(map<int, int>::iterator mit=num_a.begin(); mit!=num_a.end(); mit++) {
		    vc.push_back(pair<int, int>(mit->first, mit->second));//这一段是装进vector容器里面
		    
	    }
	    sort(vc.begin(), vc.end(), cmp);

	    for(vit=vc.begin(); vit!=vc.end(); vit++) {
		    
            int currentNum = vit->first;
            int currentSum = vit->second;
            
            bool flag = true;
            for(int i = 0;i < len;i++){
                if(A[i] == currentNum || B[i] == currentNum){
                    
                }else{
                    flag = false;
                    break;
                }
            }

            if(flag){
                minres = len - currentSum;
            }else{
                continue;
            }
	    }

        vc.clear();

        for(map<int, int>::iterator mit=num_b.begin(); mit!=num_b.end(); mit++) {
		    vc.push_back(pair<int, int>(mit->first, mit->second));//这一段是装进vector容器里面
	    }
	    sort(vc.begin(), vc.end(), cmp);

	    for(vit=vc.begin(); vit!=vc.end(); vit++) {
		    
            int currentNum = vit->first;
            int currentSum = vit->second;
            
            bool flag = true;
            for(int i = 0;i < len;i++){
                if(B[i] == currentNum || A[i] == currentNum){
                    
                }else{
                    flag = false;
                    break;
                }
            }

            if(flag){
                if(len - currentSum < minres){
                    minres = len - currentSum;
                }
            }else{
                continue;
            }
	    }

        return minres;

    }
};

题目3

打乱一个没有重复元素的数组。

思路及代码

这个没什么好说的了，比较好奇OJ如何判断这种题目，随机数就能完全确定概率一致吗

class Solution {
public:
    vector<int> temp;

    Solution(vector<int>& nums) {
        temp=nums;
    }
    
    /** Resets the array to its original configuration and return it. */
    vector<int> reset() {
        return temp;
    }
    
    /** Returns a random shuffling of the array. */
    vector<int> shuffle() {
        vector<int> ret;
        for(int i = 0;i < temp.size();i++){
            ret.push_back(temp[i]);
        }

        for(int i = 0;i < ret.size();i++){
            int pos=rand()%(i+1);

            int tmp=ret[i];
            ret[i]=ret[pos];
            ret[pos]=tmp;
        }

        return ret;
    }
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */