【USACO】clocks 遇到各种问题 最后还是参考别人的思路

//放在USACO上一直通不过 不知道哪里出了问题 输出的n总是等于1 但是BFS递归的次数是对的 《----这个问题解决了 局部变量压入queue中返回就是对的了
#include<iostream>
#include <fstream>
#include<cstring>
#include<queue>
using namespace std;

typedef struct
{
    int clock[]; //当前状态
    int sq[]; //已扩展序号
    int n;  //已扩展次数
}CS;

int clockadd(int* c)
{
    int t = *c;
    if(t == )
        t = ;
    else
        t = t + ;
    *c = t;
    return ;
}
int Move(int m, int *clock)
{
    switch(m)
    {
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    default:
        break;
    }
    return ;
}

int clockok(int * clock)
{
    int i;
    for(i = ; i < ; i++)
    {
        if(clock[i] != )
            return ;
    }
    return ;
}

queue <CS> q;
//CS tmp;

int BFS()
{
    int i, j;
    CS f = q.front();
    for(i = ; i <= ; i++)
    {
        CS tmp = f;
        tmp.n = f.n;
        Move(i, tmp.clock);
        tmp.n = tmp.n + ;
        tmp.sq[tmp.n - ] = i;
        if(clockok(tmp.clock))
        {
　　　　　　　q.push(tmp);
　　　　　　　return 0;    //后面改成用 ans = q.back()即可  
            //return tmp;
        }
        else
        {
            q.push(tmp);
        }
    }
    q.pop();
    BFS();
}
int main()
{

    fstream in, out;
    int i;
    CS first, ans;
    in.open("clocks.in", ios::in);
    out.open("clocks.out", ios::out);

    //初始化
    for(i = ; i < ; i++)
    {
        in >> first.clock[i];
    }
    memset(first.sq, , sizeof(first.sq));
    first.n = ;
    q.push(first);

    ans = BFS();

    for(i = ; i < ans.n; i++)
    {
        out << ans.sq[i] << " ";
    }
    out << "\n";    

    return ;
}

①放在USACO上一直通不过 不知道哪里出了问题 输出的n总是等于1 但是BFS递归的次数是对的。在自己的电脑上则是对的

　　解决：返回局部变量导致的错误 压入queue中再取出则是对的 具体原因还没搞清楚

②遇到新问题 递归溢出了了 递归到时钟旋转5次时会溢出 而有时答案要旋转很多次 如何提高效率？
   解决： 这道题用递归大概不可以吧 我写的函数每次递归需要存储过多的变量 在上面程序中递归3000多次就溢出了 后来把递归函数内的各种局部变量都改到外面 改成全局的 不用每次递归创建 但是运行到7000多次也溢出了 对于本题需要4^9 = 363144次递归 远远超出了栈的内存限制 只好用9层循环了

解题关键： 操作的顺序是无关紧要的！！！！  每种操作不会多于3次 否则就相当于没做了 AC的代码 非常的丑  之后尝试用这个思路对BFS剪枝 但是由于②中的分析原因 剪枝后还是溢出了

学习心得：能用循环的还是用循环吧 循环不好写 或是意义不明的在考虑递归！

//用BFS做不出来 太不爽了 在网上看了别人的思路 每个操作做4次相当于没做 所以只对每个操作做0 - 3次 枚举即可
#include<stdio.h>

int clockadd(int* c)
{
    int t = *c;
    if(t == )
        t = ;
    else
        t = t + ;
    *c = t;
    return ;
}

int clockok(int * clock)
{
    int i;
    for(i = ; i < ; i++)
    {
        if(clock[i] != )
            return ;
    }
    return ;
}

int Move(int m, int *clock)
{
    switch(m)
    {
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    case :
        {
            clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]); clockadd(&clock[]);
        }
        break;
    default:
        break;
    }
    return ;
}

int MoveN(int * clock, int * i)
{
    int j, k;
    for(j = ; j < ; j++)
    {
        for(k = ; k < i[j]; k++)
        {
            Move(j+, clock);
        }
    }
    return ;
}

int main()
{
    FILE *in, *out;
    in = fopen("clocks.in", "r");
    out = fopen("clocks.out", "w");
    int clock[];
    int i[] = {}, j, k;

    for(j = ; j < ; j++)
    {
        fscanf(in, "%d", &clock[j]);
    }

    for(i[] = ; i[] < ; i[]++)
    {
        for(i[] = ; i[] < ; i[]++)
        {
            for(i[] = ; i[] < ; i[]++)
            {
                for(i[] = ; i[] < ; i[]++)
                {
                    for(i[] = ; i[] < ; i[]++)
                    {
                        for(i[] = ; i[] < ; i[]++)
                        {
                            for(i[] = ; i[] < ; i[]++)
                            {
                                for(i[] = ; i[] < ; i[]++)
                                {
                                    for(i[] = ; i[] < ; i[]++)
                                    {
                                        int clockcp[];
                                        for(j = ; j < ; j++)
                                        {
                                            clockcp[j] = clock[j];
                                        }
                                        MoveN(clockcp, i);
                                        if(clockok(clockcp))
                                        {
                                            for(j = ; j < ; j++)
                                            {
                                                for(k = ; k < i[j]; k++)
                                                {
                                                    fprintf(out, "%d ", j + );
                                                }
                                            }
                                            fseek(out, -, SEEK_END);
                                            fprintf(out, "\n");
                                            return ;
                                        }

                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

}

 又看了下答案的解题思路 有个简便的算法是 先求出单独把每个时钟旋转90度需要对 1 - 9 的操作分别作多少次。 然后，求出输入的矩阵需要分别对 哪些时钟分别旋转几次 把需要的操作步数相加 模4 即可  <---很聪明的方法啊！