【思特奇杯·云上蓝桥-算法集训营】第2周

1. 带分数

import java.util.Scanner;

public class Main {

       public static int cnt=0,num=0;

       public static boolean bool[]=new boolean[10];

       public static void main(String[] args) {

              Scanner sc=new Scanner(System.in);

        num=sc.nextInt();

        sc.close();

        for(int i=1;i<=7;i++)

             for(int j=1;j<=7;j++)

                    if(9-i-j>=1)

                    {

                           dfs(0,0,0,i,j,9-i-j);

                    }

        System.out.println(cnt);

       }

       public static void dfs(int a,int b,int c,int alen,int blen,int clen)

       {

              if(alen==0&&blen==0&&clen==0)

              {

                     if(b%c==0&&b/c==num-a)

                     {

                            cnt++;

                     }

                     return;

              }

              for(int i=1;i<10;i++)

              {

                     if(!bool[i])

                     {

                            bool[i]=true;

                            if(alen>0)

                                   dfs(a*10+i,b,c,alen-1,blen,clen);

                            else if(blen>0)

                                   dfs(a,b*10+i,c,alen,blen-1,clen);

                            else if(clen>0)

                                   dfs(a,b,c*10+i,alen,blen,clen-1);

                            bool[i]=false;

                     }

              }

       }

}

1. 李白打酒

public class Main {

    public static int counter = 0;

    public static void main(String[] args){

//        long startTime = System.currentTimeMillis();

        drinkJiu(14, 9, 5, 2);

        System.out.println(counter);

//        long endTime = System.currentTimeMillis();

//        System.out.println("time="+(endTime-startTime));

    }

   

    public static void drinkJiu(int step, int hua, int dian, int jiu){

        if(step<0 || dian<0||hua<0||jiu<1) return;

        if(hua==0 && dian==0 && jiu==1){

            counter++;

            return;

        }

        drinkJiu(step-1, hua-1, dian, jiu-1); // 遇到花

        drinkJiu(step-1, hua, dian-1, jiu*2); // 遇到店

    }

}

1. 第39级台阶

public class Main{

       static int count = 0;

       public static void main(String[] args){

              f(0,0);

              System.out.println(count);

       }

       public static void f(int step,int stairs){

              if(stairs > 39) return;

              if(stairs == 39){

                     if(step % 2 ==0){

                            count++;

                     }

                     return;

              }

              f(step+1,stairs+1);

              f(step+1,stairs+2);

       }

}

1. 穿越雷区

import java.util.Scanner;

class Main {

  static char [][] maze = new char[100][100];   //保存+-

  static int n;

  static int [][] art = {{1,0},{0,1},{-1,0},{0,-1}};  //方向数组，通过初始化好方向数组使得改变方向可以通过循环的形式

  static boolean [][] vis = new boolean[100][100]; //记忆化数组

  static int ans = 2000;

      

       //判断是否越界

  public static boolean in(int dx,int dy) {

      return dx>=0&&dx<n&&dy>=0&&dy<n;

  }

  public static void dfs(int x,int y,int temp) {

      if(maze[x][y] == 'B') {

          if(temp<ans) {

              ans = temp;

          }

          return;

      }

      vis[x][y] = true;

      for(int i=0;i<4;i++) {

        //先将下一次到的位置写出来    

          int dx = x+art[i][0];

          int dy = y+art[i][1];

          if(in(dx,dy)&& maze[dx][dy]!=maze[x][y]&&!vis[dx][dy]) {

              dfs(dx, dy, temp+1);

          }

      }

      //记忆化，恢复，因为是说在一种走法中不走重复的！不是说两种走法没有交集！！！

      vis[x][y] = false;

  }

  public static void main(String[] args) {

      Scanner scanner = new Scanner(System.in);

      n = scanner.nextInt();

      int x =0;

      int y =0;

      for(int i=0;i<n;i++) {

          for(int j=0;j<n;j++) {

              maze[i][j] = scanner.next().charAt(0);

              if(maze[i][j] == 'A') {

                  x = i;

                  y = j;

              }

          }

      }

      dfs(x, y, 0);

      System.out.print(ans);

  }

}

1. 迷宫

class Node{    //节点

    int x, y;

    void node(int x, int y) {

        this.x = x;

        this.y = y;

    }

}

class Main {

    static int n,m;

    static char [][] dir = new  char[30][50];

    static Queue<Node> queue = new LinkedList<Node>();

    static int a[] = {1, 0, 0, -1};

    static int b[] = {0, -1, 1, 0};

    static char s[] = {'D', 'L', 'R', 'U'};

    static int [][] len = new int[30][50];

    static void bfs() {

        Node s = new Node();

        s.x = n - 1;

        s.y = m - 1;

        len[n - 1][m - 1] = 0;

        queue.offer(s);

        while(!queue.isEmpty()) {

            s = queue.poll();

            for(int i = 0; i < 4; i++) {

                int ax = s.x + a[i];

                int by = s.y + b[i];

                if(ax >= 0 && ax < n && by >= 0 && by < m && len[ax][by] == -1 && dir[ax][by] == '0') {

                    len[ax][by] = len[s.x][s.y] + 1;

                    Node node = new Node();

                    node.x = ax;

                    node.y = by;

                    queue.offer(node);

                }

            }

        }

    }

    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);

        n = 30;

        m = 50;

        for(int i = 0; i < 30; i++) {

            String s = sc.next();

            for(int j = 0; j < 50; j++) {

                len[i][j] = -1;

                dir[i][j] = s.charAt(j);

            }

        }

        bfs();

        System.out.println(len[0][0]);

        int x = 0; int y = 0;

        String p = "";

        while(x != n-1 || y != m-1) {

            W:      for(int i = 0; i < 4; i++) {

                int ax = x + a[i];

                int by = y + b[i];

                if(ax >= 0 && ax < n && by >= 0 && by < m && len[ax][by] != -1 && dir[ax][by] == '0') {

                    if(len[x][y] == len[ax][by] + 1) {

                        x = ax;

                        y = by;

                        p += s[i];

                        break W;

                    }

                }

            }

        }

        System.out.print(p);

    }

}

1. 跳马

import java.util.Scanner;

import java.util.*;

public class Main{

    static  int[][] dir={{1, 2}, {1, -2}, {-1, 2}, {-1, -2}, {2, 1}, {2, -1,}, {-2, 1}, {-2, -1}};

    public static void main(String[] args) {

        System.out.println(bfs());

    }

    private static int bfs() {

        int min=Integer.MAX_VALUE;

        int[][] arr= new int[9][9];

        Scanner scanner = new Scanner(System.in);

        int x1=scanner.nextInt();

        int y1=scanner.nextInt();

        int x2=scanner.nextInt();

        int y2=scanner.nextInt();

        if (x1==x2&&y1==y2) return 0;

        LinkedList<int[]> queue = new LinkedList<>();

        queue.add(new int[]{x1,y1,0});

        arr[x1][y1]=1;

        while (!queue.isEmpty()){

            int[] poll = queue.poll();

            x1=poll[0];

            y1=poll[1];

            if (x1==x2&&y1==y2) break;

            for (int i = 0; i < dir.length; i++) {

                int m=x1+dir[i][0];

                int n=y1+dir[i][1];

                if (m<1||m>8||n<1||n>8){

                    continue;

                }

                if (arr[m][n]==1) continue;

                //符合条件的8个均入队

                queue.addLast(new int[]{m,n,poll[2]+1});

                if (m==x2&&n==y2){

                    min=Math.min(poll[2]+1,min);

                }

            }

        }

        return min;

    }

}

1. 路径之谜

import java.util.ArrayList;

import java.util.Scanner;

public class Main {

       static int[][] dir = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };

       static ArrayList<Integer> list = new ArrayList<Integer>();

       static int N;

       static int[] north;

       static byte[] visit;

       public static void main(String[] args) {

              Scanner sc = new Scanner(System.in);

              N = sc.nextInt();

              north = new int[N];

              west = new int[N];

              for (int i = 0; i < N; i++) {

                     north[i] = sc.nextInt();

              }

              for (int i = 0; i < N; i++) {

                     west[i] = sc.nextInt();

              }

              visit = new byte[N * N];

              dfs(0, 0);

              sc.close();

       }

       static void dfs(int x, int y) {

              int index = x * N + y;

              visit[index] = 1;

              north[y]--;

              west[x]--;

              list.add(index);

              if (index == N * N - 1) {

                     for (int i = 0; i < N; i++) {

                            if (north[i] > 0 || west[i] > 0)

                                   return;

                     }

                     for (int i = 0; i < list.size(); i++) {

                            System.out.print(list.get(i) + " ");

                     }

                     return;

              }

              for (int i = 0; i < dir.length; i++) {

                     int nextx = x + dir[i][0];

                     int nexty = y + dir[i][1];

                     if (nextx < 0 || nextx >= N || nexty < 0 || nexty >= N)

                            continue;

                     if (north[nexty] <= 0 || west[nextx] <= 0)

                            continue;

                     dfs(nextx, nexty);

                     list.remove(list.size() - 1);

                     north[nexty]++;

                     west[nextx]++;

                     visit[nextx * N + y] = 0;

              }

       }

}

1. 未名湖边的烦恼

import java.util.Scanner;

public class Main{

    public int getArrange(int m, int n) {

        if(m < n)

            return 0;

        if(n == 0)

            return 1;

        return getArrange(m - 1, n) + getArrange(m, n - 1);

    }

    public static void main(String[] args){

        Main test = new Main();

        Scanner in = new Scanner(System.in);

        int m = in.nextInt();

        int n = in.nextInt();

        System.out.println(test.getArrange(m, n));

       

}

}

1. 大臣的旅费

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Scanner;

//动态链表ArrayList

class Vertex{

       ArrayList<Integer> V=new ArrayList();

}

class Edge{

       ArrayList<Integer> E=new ArrayList();

}

public class Main {

    final static int INF=0X3f3f3f3f;

    final static int maxn=100000;//开100000数组才过，我r

    static Vertex v[]=new Vertex[maxn+5];//v[i]存储与i相邻接的节点

    static Edge e[]=new Edge[maxn+5];//e[i]存储与i相邻接的边，与v[i]一一对应

    static boolean vis[]=new boolean[maxn+5];//防止重复访问

    static int dis[]=new int [maxn+5];//存储原始节点到各节点的dfs距离

   

    static void init(int n)//初始化

    {

          for(int i=0;i<n;i++)

          {

                 v[i]=new Vertex();

                 e[i]=new Edge();

          }

    }

  

 

    static void dfs(int a)

    {

          int len=v[a].V.size();

          vis[a]=true;

          for(int i=0;i<len;i++)//遍历邻接节点

          {

                 int j=v[a].V.get(i);

                 if(!vis[j]&&e[a].E.get(i)!=INF)

                 {

                       

                        vis[j]=true;

                        dis[j]=dis[a]+e[a].E.get(i);

                        //System.out.println(a+" "+j+" "+dis[j]);

                        dfs(j);

                        vis[j]=false;//回溯

                 }

          }

    }

  

    public static void main(String[] args) {

       

       Scanner cin = new Scanner(System.in);

              int n=cin.nextInt();

             

          init(n);

          for(int i=0;i<n-1;i++)

          {

                 int a=cin.nextInt();

                 int b=cin.nextInt();

                 int d=cin.nextInt();

                 v[a-1].V.add(b-1);//节点从零开始

                 e[a-1].E.add(d);

                 v[b-1].V.add(a-1);

                 e[b-1].E.add(d);

          }

          Arrays.fill(vis,false);

          Arrays.fill(dis,INF);

          dis[0]=0;

          dfs(0);//第一次遍历

          long max=-1;

          int temp=-1;

          for(int i=0;i<n;i++)

          {

                 if(dis[i]>max)

                 {

                        max=dis[i];

                        temp=i;

                 }

          }

          //System.out.println(temp);

         

          Arrays.fill(vis,false);

          Arrays.fill(dis,INF);

          dis[temp]=0;

          dfs(temp);//第二次遍历

          long ans=-1;//防止越界

              for(int i=0;i<n;i++)

          {

                 if(dis[i]>ans)

                 {

                        ans=dis[i];

                        temp=i;

                 }

          }

              //System.out.println(ans);

              ans=ans*10+ans*(ans+1)/2;//如果ans是int的话，有可能越界

              System.out.println(ans);

              cin.close();

    }

}

1. 2n皇后问题

import java.util.Scanner;

public class Main {

       static int sum=0;//统计符合的数目

       public static void main(String[] args)

       {

              Scanner db=new Scanner (System.in);

              int n=db.nextInt();

              int arr[]=new int [n]; //皇后放置位置

              int wee[][]=new int [n][n];// 接受输入时的0 1

              for(int i=0; i<n; i++)

                     for(int j=0; j<n; j++)

                            wee[i][j]=db.nextInt();

              queen(0, 0, arr, wee);//递归调用

              System.out.println(sum);

       }

       public static int queen(int su, int k, int arr[], int[][] wee)

       //su==0表示落子的是白皇后      为1 表示落子的是黑皇后   k表示第k个皇后

       {

              if(k==arr.length)//如果所有皇后都放置

              {

                     if(su==0)//判断放置的是否是白皇后

                     {

                            arr=new int[arr.length];    //如果白皇后都被放置，初始化黑皇后的位置

                            queen(su+1, 0, arr, wee);

                     }

                     if(su==1)//判断放置的是否是白皇后

                            sum++;  //统计2n皇后的放置种数

                     return sum;

              }

              for(int i=0; i<arr.length; i++)//判断第k个皇后位置（列数）行数为k

              {

                     if(wee[k][i]==0)   //如果当前位置坐标值为零，则不能放置皇后

                            continue;

                     int j;

                     for(j=0; j<k; j++)//前k-1个皇后位置（列数）行数 为j

                            if(arr[j]==i||Math.abs(arr[j]-i)==(k-j))//判断皇后之间是否存在同一列，统一对角线冲突

                                   break;

                     if(j==k)//条件成立时表示第k个与之前的没有冲突

                     {

                            arr[k]=i; //第k个皇后位置

                            wee[k][i]=0; //将此位置即为0 表示不能再这放置皇后

                            queen(su, k+1, arr, wee);  //递归调用下一层

                            wee[k][i]=1;

                     }

              }

              return sum;

       }

}