SRM 550 DIV2

还是老样子，悲催，只做出来一个，第二个因为没有考虑一种情况，导致代码写错了

第一题就是简单的比较两个字符串中不同的就OK了，最后用数字差模2比较一下就行。

第二题以为可以在任意地方拐弯，实际上必须碰到边缘才可以，后来发现的时候没时间改代码了，悲催。

思路就是先比较边界的情况，如果合法的话时间上就是在一个矩形中绕圈，判断一下是否合法就OK了。

#include <iostream>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cmath>
 #include <map>
 #include <algorithm>
 #include <list>
 using namespace std;
 
 
 class RotatingBot{
 public:
     int minArea(vector <int> moves){
         int squ=0;
         int left,top;
         int x,y;
         left=top=0;
         int s=moves.size();
         if(s==1){
             return moves[0]+1;
         }else if(2==s){
             return (moves[0]+1)*(moves[1]+1);
         }else if(3==s){
             left = max(moves[0], moves[2]);
             return (left+1)*(moves[1]+1);
         }else if(4==s){
             if(moves[2]>moves[0]){
                 left = max(moves[0], moves[2]);
                 top = max(moves[1],moves[3]);
                 return (left+1)*(top+1);
             }else if(moves[2]==moves[0]){
                 left = max(moves[0], moves[2]);
                 top = max(moves[1],moves[3]);
                 if(moves[3]<moves[1])
                     return (left+1)*(top+1);
                 else
                     return -1;
             }else{
                 return -1;
             }
         }else{
             if (moves[2] > moves[0]) {
                 if (moves[3] > moves[1]) {
                     x = moves[2] ;
                     y = moves[3] - moves[1] - 1;
                     squ=(moves[3]+1)*(moves[2]+1);
                 } else if (moves[3] == moves[1]) {
                     x = moves[2] - moves[0] - 1;
                     y = moves[3] - 1;
                     squ=(moves[3]+1)*(moves[2]+1);
                 } else
                     return -1;
             } else if (moves[2] == moves[0]) {
                 if (moves[3] == moves[1] - 1) {
                     x = moves[2] - 1;
                     y = moves[3] - 1;
                     squ=(moves[1]+1)*(moves[2]+1);
                 } else
                     return -1;
             } else {
                 return -1;
             }
         }
         int tag=0;
         int i=4;
         for(;i<moves.size()-1;i++){
             if(0==tag){
                 if(moves[i]==x){
 
                 }else{
                     return -1;
                 }
             }else{
                 if(moves[i]==y){
                     x--;
                     y--;
                 }else{
                     return -1;
                 }
             }
             tag=(tag+1)%2;
         }
         if (0 == tag) {
             if (moves[i] <= x) {
 
             } else {
                 return -1;
             }
         } else {
             if (moves[i] <= y) {
             } else {
                 return -1;
             }
         }
         return squ;
     }
 
 };

第三题是看了strongczq的代码才懂得，改了改写成了C++。

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <algorithm>
#include <map>
using namespace std;

class TopView {
public:
    string findOrder(vector<string> grid) {
        set<char> colorSet;
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                char ch = grid[i][j];
                if (ch != '.') {
                    colorSet.insert(ch);
                }
            }
        }
        //grid包含的所有颜色
        char* colors = new char[colorSet.size()];
        //颜色->索引值(colors数组的索引值)映射
        int colorIndex[256];
        int cnt = 0;
        set<char>::iterator itcolor;
        for (itcolor = colorSet.begin(); colorSet.end() != itcolor; itcolor++) {
            colorIndex[unsigned(*itcolor)] = cnt;
            colors[cnt++] = *itcolor;
        }

        //卡片依赖关系，被依赖的必须先放置
        map<int, map<int, bool> > dep;
        for (int i = 0; i < cnt; i++)
            for (int j = 0; j < cnt; j++)
                dep[i][j] = false;
        for (int i = 0; i < cnt; ++i) {
            char ch = colors[i];
            int minR = 1000, maxR = -1, minC = 1000, maxC = -1;
            for (int r = 0; r < grid.size(); ++r) {
                for (int c = 0; c < grid[0].size(); ++c) {
                    if (grid[r][c] == ch) {
                        minR = min(minR, r);
                        maxR = max(maxR, r);
                        minC = min(minC, c);
                        maxC = max(maxC, c);
                    }
                }
            }
            for (int r = minR; r <= maxR; ++r) {
                for (int c = minC; c <= maxC; ++c) {
                    char ch2 = grid[r][c];
                    if (ch2 == '.') {
                        return "ERROR!";
                    } else if (ch2 == ch) {
                        continue;
                    }
                    int j = colorIndex[(unsigned int) ch2];
                    dep[j][i] = true;
                }
            }
        }
        string res;
        //每个卡片依赖的其他卡片数
        int* depNum = new int[cnt];
        for (int i = 0; i < cnt; ++i)
            depNum[i] = 0;
        for (int i = 0; i < cnt; ++i) {
            for (int j = 0; j < cnt; ++j) {
                if (dep[i][j]) {
                    depNum[i]++;
                }
            }
        }
        //拓扑排序
        for (int i = 0; i < cnt; ++i) {
            int choice = 2550;
            for (int j = 0; j < cnt; ++j) {
                if (depNum[j] == 0) {
                    choice = min(choice, j);
                }
            }

            if (choice == 2550) {
                return "ERROR!";
            }
            depNum[choice] = -1;
            for (int j = 0; j < cnt; ++j) {
                if (dep[j][choice]) {
                    depNum[j]--;
                }
            }
            res = res + colors[choice];
        }
        return res;
    }
};