USACO Runaround Numbers

1、唉，我真是太浮躁了，不好好读题，所以做错了两次。

2、要注意题干中说digits是“unique”的，也就是各不相同，还说每次产生的新数不能和原数相同（其实和前一个条件是一个意思）。

3、我还把memset写到循环外面了，造成死循环，其实只要测试一下81360这个数字就能发现问题了，但我就是抱有侥幸心理。。。

4、以后要注意！

/*
ID:mrxy564
PROG:runround
LANG:C++
*/
#include<cstdio>
#include<cstring>
using namespace std;
int main(){
 //freopen("runround.in","r",stdin);
 //freopen("runround.out","w",stdout);
    int n,len,temp,now,map[10];
 bool flag[20];
 char s[20];
 scanf("%d",&n);
 for(int i=n+1;;i++){
     sprintf(s,"%d",i);
        len=strlen(s);
  now=0;
  bool find=true;
  int last=-1;
  memset(flag,false,sizeof(flag));
  for(int j=0;j<len;j++){
   if(flag[now]){
    find=false;
          break;
   }
      temp=s[now]-'0';
   if(temp==last){
    find=false;
    break;
   }
   last=temp;
   flag[now]=true;
   now=(now+temp)%len;
 
  }
  if(find && 0==now && s[now]-'0'!=last){
   printf("%d\n",i);
      break;
  }
 }
 return 0;
}

官方题解：

The trick to this problem is noticing that since runaround numbers must have unique digits, they must be at most 9 digits long. There are only 9! = 362880 nine-digit numbers with unique digits, so there are fewer than 9*362880 numbers with up to 9 unique digits. Further, they are easy to generate, so we generate all of them in increasing order, test to see if they are runaround, and then take the first one bigger than our input.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

int m;
FILE *fout;

/* check if s is a runaround number;  mark where we've been by writing 'X' */
int
isrunaround(char *s)
{
    int oi, i, j, len;
    char t[10];

    strcpy(t, s);
    len = strlen(t);

    i=0;
    while(t[i] != 'X') {
	oi = i;
	i = (i + t[i]-'0') % len;
	t[oi] = 'X';
    }

    /* if the string is all X's and we ended at 0, it's a runaround */
    if(i != 0)
	return 0;

    for(j=0; j<len; j++)
	if(t[j] != 'X')
	    return 0;

    return 1;
}

/*
 * create an md-digit number in the string s.
 * the used array keeps track of which digits are already taken.
 * s already has nd digits.
 */
void
permutation(char *s, int *used, int nd, int md)
{
    int i;

    if(nd == md) {
	s[nd] = '\0';
	if(atoi(s) > m && isrunaround(s)) {
	    fprintf(fout, "%s\n", s);
	    exit(0);
	}
	return;
    }

    for(i=1; i<=9; i++) {
	if(!used[i]) {
	    s[nd] = i+'0';
	    used[i] = 1;
	    permutation(s, used, nd+1, md);
	    used[i] = 0;
	}
    }
}


void
main(void)
{
    FILE *fin;
    char s[10];
    int i, used[10];

    fin = fopen("runround.in", "r");
    fout = fopen("runround.out", "w");
    assert(fin != NULL && fout != NULL);

    fscanf(fin, "%d", &m);

    for(i=0; i<10; i++)
	used[i] = 0;

    for(i=1; i<=9; i++)
	permutation(s, used, 0, i);

    assert(0);	/* not reached */
}

Another look

Diego Exactas from Argentina has a better solution that runs extremely quickly.

This is my solution, with doesn't generate all solutions, but just looks for the next one.

#include <fstream>
#include <string>
#include <vector>
#include <algorithm>

#define INPUT_FILE "runround.in"
#define OUTPUT_FILE "runround.out"

using namespace std;

void NextNumber(std::vector<int>& number, int Digits) {
    number[Digits - 1]++;
    for (int i = Digits - 1; i >= 0; i--) {
        if (number[i] == 10) {
            number[i] = 1;
            if (i == 0) {
                number.insert (number.begin(),1);
                return;
            } else 
                number[i - 1]++;
        }
    }
    return;
}

bool CheckElement(std::vector<int>::iterator first,
    std::vector<int>::iterator last, int val) {
    while (first < last) {
        if (*first == val) 
            return true;
        ++first;
    }
    return false;
}

void NextUniqueNumber(std::vector<int>& number) {
    std::vector<int> old = number;
    for (int i = 1; i < number.size(); ++i) {
        if (number[i] == 0) number[i]++;
        while (CheckElement (number.begin(),number.begin() + i,number[i])) {
            number[i]++;
            if (number[i] == 10) {
                number[i] = 1;
                NextNumber (number,i);
                i = 1;
                continue;
            }
        }
    }
    return;
}

bool IsRoundNumber(std::vector<int>& number) {
    std::vector<bool> used(10,false);
    for (int i = 0, pos = 0, val = number[0]; i < number.size(); i++) {
        pos = (pos + val) % number.size();
        val = number[pos];
        if (used[pos] == true) return false;
        used[pos] = true;
    }
    return true;
}

unsigned int NextRoundNumber(unsigned int number) {
    std::vector<int> digits;
    for (int i = 0, tens = 1; i <= 10; ++i, tens *= 10) {
        int partial = number / tens;
        if (partial == 0) break;
        partial %= 10;
        digits.push_back(partial);
    }
    std::reverse (digits.begin(),digits.end());
    NextNumber (digits,digits.size());
    NextUniqueNumber (digits);
    while (!IsRoundNumber(digits)) {
        NextNumber (digits,digits.size());
        NextUniqueNumber (digits);
    }
    number = 0;
    for (int i = 0; i < digits.size(); i++) 
        number = 10 * number + digits[i];
    return number;
}

int main(int argc, char *argv[]) {
    ifstream FileInput (INPUT_FILE);
    ofstream FileOutput (OUTPUT_FILE);
    unsigned int Number;
    FileInput >> Number;
    FileOutput << NextRoundNumber(Number) << "\n";
    return 0;
}