[LeetCode]205. 同构字符串/207. 课程表

题目描述：给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
题目链接：205. 同构字符串

map

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        map<char,char> m;
        bool help[300];
        memset(help,false,sizeof(help));
        int tip1=s.size();
        int tip2=t.size();
        tip2=min(tip1,tip2);
        //if (tip1!=tip2) return false;
        for (int i=0;i<tip2;i++){
            if (m.find(s[i])==m.end()){
                m[s[i]]=t[i];
                if (help[t[i]]) return false;
                help[t[i]]=true; //不能映射到同一个字符上
            }
            else{
                if (m[s[i]]==t[i]) continue;
                return false;
            }
        }
        return true;
    }
};

题目描述：现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
题目链接：207. 课程表

简单的拓扑排序。

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        int tip=prerequisites.size();
        int cnt=0;
        int num[10005];
        bool used[10005];
        vector<int> f[10005];
        memset(used,false,sizeof(used));
        memset(num,0,sizeof(num));
        for (int i=0;i<tip;i++){
            int tip1=prerequisites[i].size();
            num[prerequisites[i][0]]+=tip1-1; //课程入度
            for (int j=1;j<tip1;j++){
                f[prerequisites[i][j]].push_back(prerequisites[i][0]);
            }
        }
        queue<int> q;
        for (int i=0;i<numCourses;i++){
            if (num[i]==0){
                cnt++;
                q.push(i);
                used[i]=true; //已经入队
            }
        }
        if (q.empty()) return false;
        //拓扑排序
        while (!q.empty()){
            int now=q.front();
            q.pop();
            for (int i=0;i<f[now].size();i++){
                num[f[now][i]]--;
                if (num[f[now][i]]==0){
                    if (used[f[now][i]]) return false; //存在循环
                    q.push(f[now][i]);
                    cnt++;
                    used[f[now][i]]=true;
                }
            }
        }
        if (cnt<numCourses) return false;
        return true;
    }
};