2020/4/20每日一练_gerkmann-优快云博客

2020/4/20

1.思维+暴力

传送门
大意就是给一个长度为100的数字的串，找出其中能够被8整除的一个子序列。
其实就是利用一个数能够被8整除后三位就可以被8整除的原理（因为1000的整数倍一定是8的倍数，同理还有4的是后两位）。
所以三重循环枚举一下每一位，注意结果并不一定是三位，也有16，8这样的所以每重循环都要判断一下，代码如下。

	string s;
    cin >> s;
    for (int i = 0; i < s.size(); ++i) {
        int num = (s[i] - '0');
        if (num % 8 == 0) {
            cout << "YES" << endl;
            cout << num << endl;
            return 0;
        }
        for (int j = i + 1; j < s.size(); ++j) {
            int num = (s[i] - '0') * 10 + (s[j] - '0');
            if (num % 8 == 0) {
                cout << "YES" << endl;
                cout << num << endl;
                return 0;
            }
            for (int k = j + 1; k < s.size(); ++k) {
                int num = (s[i] - '0') * 100 + (s[j] - '0') * 10 + s[k] - '0';
                if (num % 8 == 0) {
                    cout << "YES" << endl;
                    cout << num << endl;
                    return 0;
                }
            }
        }
    }
    cout << "NO" << endl;

2.dp

传送门
题意大概就是要求给字符串排序，但是不能动他的位置，只能把它反转过来，如果反转第i个字符串需要消耗v_i的能量之类的，求最小能量。
如果看出是dp，就很容易得转移方程。即每个字符串都会从上一个位置中（原字符串或者反转的字符串）转移过来，上代码吧。

string s[maxn][2];
int v[maxn];
ll dp[maxn][2];
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> v[i];
    }
    for (int i = 1; i <= n; ++i) {
        cin >> s[i][0];
        s[i][1] = s[i][0];
        reverse(all(s[i][1]));
    }
    memset(dp, inf, sizeof(dp));
    dp[0][0] = dp[0][0] = 0;
    for (int i = 1; i <= n; ++i) {
        if (s[i][0] >= s[i - 1][0]) dp[i][0] = min(dp[i][0], dp[i - 1][0]);
        if (s[i][0] >= s[i - 1][1]) dp[i][0] = min(dp[i][0], dp[i - 1][1]);
        if (s[i][1] >= s[i - 1][0]) dp[i][1] = min(dp[i][1], dp[i - 1][0] + v[i]);
        if (s[i][1] >= s[i - 1][1]) dp[i][1] = min(dp[i][1], dp[i - 1][1] + v[i]);
    }
    ll ans = min(dp[n][0], dp[n][1]);
    cout << (ans == 0x3f3f3f3f3f3f3f3f ? -1 : ans) << endl;
    return 0;
}

3.拓扑排序

传送门
题意就是给出n个字符串，这些是排好序的，要求他的字典序是什么。
根据排序的定义很明显s_i<s_j(j>i)，于是对于每对字符串找到第一个不相等的字母，我们就可以得到一些字母的相对顺序。
得到后采取拓扑排序就可以得到字典序。
需要注意的是如果上面的字符串跑完了，下面的字符串还没有跑完(例如aa在上，a在下)，一定是impossible的，因为你无法决定“空”的字典序。

int in[26], n;
char s[maxn][maxn];
vector<int> edge[26];
int flag = 0;
void add(char *s1, char *s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int i = 0, j = 0;
    for (; i < len1 && j < len2; ++j, ++i) {
        if (s1[i] != s2[j]) {
            in[s2[j] - 'a']++;
            edge[s1[i] - 'a'].emplace_back(s2[j] - 'a');
            return;
        }
    }
    if ((i != len1) && (j == len2)) flag = 1;
}
vector<int> ans;
void topsort() {
    queue<int> q;
    for (int i = 0; i < 26; ++i) {
        if (in[i] == 0) q.push(i);
    }
    while (q.size()) {
        int t = q.front();
        q.pop();
        ans.emplace_back(t);
        for (auto &it : edge[t]) {
            in[it]--;
            if (in[it] == 0) q.push(it);
        }
    }
}
int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%s", s[i]);
    }
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            add(s[i], s[j]);
        }
    }
    topsort();
    if (ans.size() != 26 || flag) {
        puts("Impossible");
        return 0;
    }
    for (auto &it : ans) {
        printf("%c", 'a' + it);
    }
    return 0;
}