CS Academy 8 Divisible

题目链接：https://csacademy.com/contest/archive/task/8-divisible

题目大意：给出一个大数N，长度不超过1000位。现在要求将N的所有位重新排列，使得其能够被8整除。输出最小的可能解，如果没有解，输出-1. 输出不允许有前导0。

解题思路：考虑1,10,100,1000……模8，发现分别是1,2,4,0,0……。也就是说从1000开始的10的幂都能够被8整除了。那么对于由an-1,an-2……a2,a0,a1组成的数字N来说，只需要考虑最后三位即可，确定最后三位之后判断其是否为一个可行解，记录下了，最后取最小可行解或者输出-1。

大致过程：记录下N中每位每个数字出现的次数；然后从992开始每次减8枚举所有能够被8整除的3,2,1位数xi，对于每个数字xi，判断其个十百三位是否可得到，以及结果是否含有前导0； 全部记录下来最后输出字典序最小即可。

代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <string>
using namespace std;
const int maxn = 1e3 + 5;
char str[maxn];
int tis[10], len = 0;
string ans;

void doout(int a, int b, int c){
    int tps[10];
    memcpy(tps, tis, sizeof(tis));
    tps[a] -= 1; tps[b] -= 1; tps[c] -= 1;
    string tmp;
    for(int i = 1; i < 10; i++){
        if(tps[i] > 0){
            tmp.push_back(i + '0');
            tps[i] -= 1;
            break;
        }
    }
    for(int i = 0; i < 10; i++){
        if(tps[i] > 0){
            for(int j = 0; j < tps[i]; j++)
                tmp.push_back(i + '0');
        }
    }
    tmp.push_back(a + '0');
    tmp.push_back(b + '0');
    tmp.push_back(c + '0');
    if(ans.size() == 0 || tmp < ans) ans = tmp;
}
bool check(int a, int b, int c){
    int tps[10];
    memcpy(tps, tis, sizeof(tps));
    tps[a] -= 1; tps[b] -= 1; tps[c] -= 1;
    for(int i = 0; i < 10; i++) if(tps[i] < 0) return false;
    bool has3 = false;
    for(int i = 1; i < 10; i++) if(tps[i] > 0) has3 = true;
    if(has3 || (len == 3 && a != 0)) {
        doout(a, b, c);
        return true;
    }
    else return false;
}
void solve(){
    len = strlen(str);
    if(len == 1){
        int u = str[0] - '0';
        if(u % 8 == 0) puts(str);
        else puts("-1");
        return;
    }
    else if(len == 2){
        int u = str[0] - '0', v = str[1] - '0';
        if(u > v) swap(u, v);
        if((u * 10 + v) % 8 == 0 && u != 0) printf("%d%d
", u, v);
        else if((v * 10 + u) % 8 == 0 && v != 0) printf("%d%d
", v, u);
        else puts("-1");
        return;
    }
    else{
        bool flag = false;
        memset(tis, 0, sizeof(tis));
        for(int i = 0; str[i]; i++) tis[str[i] - '0']++;
        for(int i = 992; i >= 0; i -= 8){
            int x = i, a, b, c;
            a = x / 100; x %= 100;
            b = x / 10; x %= 10;
            c = x;
            if(check(a, b, c)) flag = true;
        }
        if(!flag) puts("-1");
        else{
            for(int i = 0; i < (int)ans.size(); i++)
                str[i] = (char) ans[i];
            str[ans.size()] = 0;
            puts(str);
        }
    }
}
int main(){
    scanf("%s", str);
    solve();
    return 0;
}

题目：

8 Divisible

Time limit: 1000 ms
Memory limit: 256 MB

 

You are given a large number NN. Can you permute its digits such that the new number is divisible by 88?

If the solution is not unique, print the smallest one. Leading 00s are not allowed.

Standard input

The first line contains a single large number NN.

Standard output

If there is no solution output -1−1.

Otherwise, print the answer on the first line.

Constraints and notes

• The number of digits of NN is between 11 and 1\,0001000 
• 1 leq N1≤N

Input	Output	Explanation
625	256	256256 is the only number divisible by 88 we can obtain
173	-1	There is no permutation of digits that creates a number divisible by 88.
2048	2048	02480248 is smaller, but leading 00s are not allowed.