Codeforces Round #549 (Div. 2)

A、The Doors

思路：红色为本题的解题要点，也就是Mr.Block从左往右依次打开每一个门，当第一次能打开左边出口或者右边出口的最后一个门所在的打开位置index就是要找的最小下标k。注意：题目已经保证了左右出口至少各有一个门，也就是说k一定是给定01序列中最后一个元素（与其右边相邻元素值不同）所在的下标（不超过n-1），于是倒叙遍历简单判断一下即可。

AC代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 上右下左
const int mx[8] = {-1, -2, -2, -1, 1, 2, 2, 1}; // 马可走的八个方向
const int my[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 2e5+5;
const int inf = 0x3f3f3f3f;

int n, a[maxn];

int main() {
    while(cin >> n) {
        for(int i = 0; i < n; ++i) cin >> a[i];
        for(int i = n - 2; ~i; --i)
            if(a[i] ^ a[i + 1]) {cout << i + 1 << endl; break;}
    }
    return 0;
}

B、Nirvana

思路：dfs+数位dp思想。题意就是给定一个数字n，求1~n中哪个数字中所有位上的数字相乘之后乘积最大，求这个最大乘积。我们用借用数位dp的思想去枚举每一位，无脑暴力搜索，每搜到最后一位就取乘积最大值，要记忆化搜索，也就是记录已搜到的叶子节点状态，因为这个过程会重复计算大量相同子问题。注意：要多记录一个状态：上一位是否为上界！！！其余常规出牌即可。

AC代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
typedef long long LL;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e5+5;
const int inf = 0x3f3f3f3f;

char str[15];
int len, ans, mul, per, num[15];
map<pair<int, bool>, bool> mp[15][10];

/* pos：当前位置
 * zero：pos前面拥有0的个数
 * per：pos前面所有位上的数字的乘积
 * now：上一位的数字是now
 * limit：上一位数字是否为上界
 */

void dfs(int pos, int now, int zero, int per, bool limit) {
    if(mp[pos][now][make_pair(per, limit)]) return;
    mp[pos][now][make_pair(per, limit)] = true;
    if(pos == len) {
        ans = max(ans, per);
        return;
    }
    int up = limit ? num[pos] : 9;
    for(int j = up; ~j; --j) {
        dfs(pos + 1, j, zero + !j, ((zero == pos && j) ? j : per * j), j == up && limit);
    }
}

int main() {
    while(cin >> str) {
        len = strlen(str);
        ans = 1;
        for(int i = 0; i < 15; ++i)
            for(int j = 0; j < 10; ++j)
                mp[i][j].clear();
        for(int i = 0; i < len; ++i) ans *= (str[i] - '0'), num[i] = str[i] - '0';
        dfs(0, 0, 0, 1, true); // 初始状态：乘积值为1，上界为true
        cout << ans << endl;
    }
    return 0;
}

C、Queen

思路：思维。由题可知，被删除的节点不但要不尊重其所有的祖先节点，而且与其相邻的所有儿子节点都要不尊重它。显然，每删除一个满足条件的节点，其所有儿子节点都会指向被删节点的父节点，这些儿子节点分别对应的所有儿子节点对各自的情况不变，又因为这些儿子节点之前本来就不尊重其所有祖先节点，所以现在指向被删去节点的父亲节点仍然不尊重它们，从这点可以得出我们应该去标记那些被儿子节点尊重的祖先节点，因为它们无论怎样都不会被删除，标记完之后升序遍历依次筛选即可。

AC代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 上右下左
const int mx[8] = {-1, -2, -2, -1, 1, 2, 2, 1}; // 马可走的八个方向
const int my[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e5+5;
const int inf = 0x3f3f3f3f;

int n, p, c[maxn];
bool flag, vis[maxn];
vector<int> ans;

int main() {
    while(cin >> n) {
        memset(c, 0, sizeof(c));
        memset(vis, false, sizeof(vis));
        ans.clear(); flag = false;
        for(int i = 1; i <= n; ++i) {
            // 节点i的父亲节点是p，c表示节点i是否尊重其所有祖先节点
            cin >> p >> c[i];
            // 若p不是根节点，且节点i尊重其所有祖先节点，说明节点p至少有一个儿子节点尊重它，即节点p不会被删除
            if(~p && !c[i]) vis[p] = true;
        }
        for(int i = 1; i <= n; ++i)
            // 若节点i的所有儿子都不尊重它，并且它又不尊重其所有祖先节点，则应删除它
            if(!vis[i] && c[i]) ans.push_back(i);
        for(int j = 0, siz = ans.size(); j < siz; ++j) flag = true, cout << ans[j] << " 
"[j == siz - 1];
        if(!flag) puts("-1"); // 无需删除则输出-1
    }
    return 0;
}