1. 二進位制矩陣中的特殊位置

模擬，時間複雜度\(O(n^3)\)。

class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size(), res = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(mat[i][j]) {
                    bool flag = false;
                    for(int k = 0; k < n; k++) if(k != i && mat[k][j]) flag = true;
                    for(int k = 0; k < m; k++) if(k != j && mat[i][k]) flag = true;
                    if(!flag) res++;
                }
            }
        }
        return res;
    }
};
 

2. 統計不開心的朋友

模擬，\(rank[i][j]\)表示時\(j\)在\(i\)的朋友中的親近程度排名，時間複雜度\(O(n^2)\)。

class Solution {
public:
    static const int N = 505;
    int rank[N][N], pair[N];
    int unhappyFriends(int n, vector<vector<int>>& preferences, vector<vector<int>>& pairs) {
        int ans = 0;
        for(int i = 0; i < n / 2; i++) {
            pair[pairs[i][0]] = pairs[i][1];
            pair[pairs[i][1]] = pairs[i][0];
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n - 1; j++) {
                rank[i][preferences[i][j]] = j;
            }
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(i == j || pair[i] == j) continue;
                if(rank[i][j] < rank[i][pair[i]] && rank[j][i] < rank[j][pair[j]]) {
                    ans++;
                    break;
                }
            }
        }
        return ans;
    }
};
 

3. 連線所有點的最小費用

最小生成樹，時間複雜度\(O(nlogn)\)。

class Solution {
public:
    struct edge {
        int u, v, w;
        bool operator<(const edge& rhs) const {
            return w < rhs.w;
        }
    };

    static const int N = 1000005;
    int m = 0, f[N];
    vector<edge> c;

    int find(int k) {return f[k] == k ? k : f[k] = find(f[k]);}

    int kruskal() {
        int ans = 0;
        for(int i = 0; i < N; i++) f[i] = i;
        sort(c.begin(), c.end());
        for(auto e : c) {
            if(find(e.u) != find(e.v)) f[f[e.u]] = f[e.v], ans += e.w;
        }
        return ans;
    }
    
    int minCostConnectPoints(vector<vector<int>>& points) {
        for(int i = 0; i < points.size(); i++) {
            for(int j = i + 1; j < points.size(); j++) {
                c.push_back({i, j, abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])});
            }
        }
        return kruskal();
    }
};
 

4. 檢查字串是否可以通過排序子字串得到另一個字串

貪心，需要交換至隊首的字元前不應該有比它小的字元，時間複雜度\(O(n)\)。

class Solution {
public:
    bool isTransformable(string s, string t) {
        vector<queue<int>> pos(10);
        for(int i = 0; i < s.size(); i++) {
            pos[s[i] - '0'].push(i);
        }
        for(int i = 0; i < t.size(); i++) {
            int c = t[i] - '0';
            if(!pos[c].size()) return false;
            for(int j = 0; j < c; j++) {
                if(pos[j].size() && pos[j].front() < pos[c].front()) return false;
            }
            pos[c].pop();
        }
        return true;
    }
};