USACO_1_4_The Clocks

还是用深度优先搜索，枚举每个方案使用的次数，最多有4^9=262144种情况，在加上剪枝可以更快，我是这样剪枝的，比如说当确定前4种方案各用几次后，就可以判断左上角的钟是否指向12点，因为后面的方案不会让左上角的钟转动，如果没有指向12点，则就不要继续深度搜索（在代码中对应checked(3) == false,注意代码中都是从0计数），等等

 

 

/**//*
ID: sdjllyh1
PROG: clocks
LANG: JAVA
complete date: 2008/11/20
author: LiuYongHui From GuiZhou University Of China
more article: www.cnblogs.com/sdjls
*/

import java.io.*;
import java.util.*;

public class clocks
{
    private static int[] clocks = new int[9];//clock[3]=1 表示输入文件中第3个钟为3点(2为6点、3为9点、0为12点)
    private static int[] moves = new int[9];//moves[2]=3 表示第二种方式使用3次，容易看出每种方式最多使用3次
    private static String shortestSequence = "999888777666555444333222111";//记下当前发现的最好方法
    
    public static void main(String[] args) throws IOException
    {
        init();
        run();
        output();
        System.exit(0);
    }

    private static void run()
    {
        dfs(0);
    }

    //深度优先搜索
    private static void dfs(int dep)
    {
        //如果深度为9，表示moves[0..8]都已经有了明确值，且所有钟指向12点
        if (dep == 9)
        {
            recordSequence();
        }
        else
        {
            for (int i = 0; i < 4; i++)
            {
                moves[dep] = i;
                //moves[dep]获得了一个新值，因此要检查这个新值会不会引起某个钟无法指向12点
                if (checked(dep))
                {
                    //如果不确定会引起则继续深度递归
                    dfs(dep + 1);
                }
            }
        }
    }

    //当调用checked(dep)时，moves[dep]刚刚获得了一个新值，checked函数检查这个新值会不会引起某个钟无法指向12点
    //如果不会则返回true
    private static boolean checked(int dep)
    {
        switch (dep)
        {
            case 3:
                //check clock 0
                if ((clocks[0]+moves[0]+moves[1]+moves[3]) % 4 != 0)
                {
                    return false;
                }
                break;
            case 4:
                //check clock 1
                if ((clocks[1]+moves[0]+moves[1]+moves[2]+moves[4])%4!=0)
                {
                    return false;
                }
                break;
            case 5:
                //check clock 2
                if ((clocks[2]+moves[1]+moves[2]+moves[5])%4!=0)
                {
                    return false;
                }
                break;
            case 6:
                //check clock 3
                if ((clocks[3]+moves[0]+moves[3]+moves[4]+moves[6])%4!=0)
                {
                    return false;
                }
                break;
            case 7:
                //check clock 6
                if ((clocks[6]+moves[3]+moves[6]+moves[7])%4!=0)
                {
                    return false;
                }
                break;
            case 8:
                //check clock 4
                if ((clocks[4]+moves[0]+moves[2]+moves[4]+moves[6]+moves[8])%4!=0)
                {
                    return false;
                }
                //check clock 5
                if ((clocks[5]+moves[2]+moves[4]+moves[5]+moves[8])%4!=0)
                {
                    return false;
                }
                //check clock 7
                if ((clocks[7]+moves[4]+moves[6]+moves[7]+moves[8])%4!=0)
                {
                    return false;
                }
                //check clock 8
                if ((clocks[8]+moves[5]+moves[7]+moves[8])%4!=0)
                {
                    return false;
                }
                break;
        }
        return true;
    }

    private static void recordSequence()
    {
        String thisSequence = getSequence();
        if ( (thisSequence.length() < shortestSequence.length() )
             || ((thisSequence.length() == shortestSequence.length()) && (thisSequence.compareTo(shortestSequence) < 0)))
        {
            shortestSequence = thisSequence;
        }
    }

    private static String getSequence()
    {
        String retSequence = "";
        for (int i = 0; i < 9; i++)
        {
            for (int j = 0; j < moves[i]; j++)
            {
                retSequence += (i + 1);
            }
        }
        return retSequence;
    }

    private static void init() throws IOException
    {
        BufferedReader f = new BufferedReader(new FileReader("clocks.in"));
        for (int i = 0; i < 3; i++)
        {
            StringTokenizer st = new StringTokenizer(f.readLine());
            for (int j = 0; j < 3; j++)
            {
                clocks[i*3+j] = (Integer.parseInt(st.nextToken()) / 3) % 4;
            }
        }
        f.close();
    }

    private static void output() throws IOException
    {
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("clocks.out")));
        for (int i = 0; i < shortestSequence.length() - 1; i++)
        {
            out.print(shortestSequence.charAt(i) + " ");
        }
        out.println(shortestSequence.charAt(shortestSequence.length() - 1));
        out.close();
    }
}