奇妙的算法【8】籌錢種數、定時找出最高頻次的數據、三子棋落點判斷

1，籌錢種數

　　有幾種不一樣幣值的錢幣，求有多少種可能狀況湊成m元錢

　　咔咔，直接遞歸調用超級簡單。

package com.cnblogs.mufasa.Main1;

import java.util.Arrays;
import java.util.Scanner;

public class Solution {

    public static int RecuDeal(int[] nums,int sum,int index){
        int cont=0;
        if(index==nums.length-1){//1，退出條件：只有最後一個數據選項
            if(sum%nums[index]==0){//1,1能夠匹配上，餘數爲0
                cont= 1;
            }else {//1,2 沒法匹配上，餘數不爲零
                cont= 0;
            }
        }else {//2，還有多個數據能夠選擇，進一步進行拆分遞進遞歸
            int temp=sum/nums[index];
            for(int i=0;i<=temp;i++){
                cont+=RecuDeal(nums,sum-nums[index]*i,index+1);//遞歸節點
            }
        }
        return cont;
    }

    public static void main(String[] args) {

        //1,測試
        int[] nums=new int[]{5,2,1};
        int sum=10;

        //2,輸入
//        Scanner sc=new Scanner(System.in);
//        String[] strs=sc.nextLine().split(" ");
//        int sum=sc.nextInt();
//        int[] nums=new int[strs.length];
//        for(int i=0;i<strs.length;i++){
//            nums[i]=Integer.valueOf(strs[i]);
//        }

        //3，輸出
        System.out.println(RecuDeal(nums,sum,0));//輸出結果爲10正確
    }
}
/*
5 2 1
10

 */

2，計算機日誌報告使用頻次

　　輸出每五分鐘內使用頻次最大的數據頻次及其名稱

　　咔咔，①使用Node節點類型將這個對象進行實例化，方便計算時間，存儲名稱；②使用hashMap來進行頻次的統計，key爲咱們定義的數據

package com.cnblogs.mufasa.Main2;

import java.util.*;

class myDate{
    int year;
    int month;
    int day;
    int hour;
    int min;
    int sec;
    public myDate(String str){
        this.year=Integer.valueOf(str.substring(0,4));
        this.month=Integer.valueOf(str.substring(5,7));
        this.day=Integer.valueOf(str.substring(8,10));
        this.hour=Integer.valueOf(str.substring(11,13));
        this.min=Integer.valueOf(str.substring(14,16));
        this.sec=Integer.valueOf(str.substring(17,19));
    }

    //用於判斷是否超過5分鐘
    public boolean subDate(myDate o){
        if(o.year>year){
            return true;
        }
        if(o.month>month){
            return true;
        }
        if(o.day>day){
            return true;
        }
        if(o.hour>hour){
            return true;
        }
        if(o.min-min>5){
            return true;
        }else if(o.min-min==5){//分鐘時刻恰好相差5min，須要使用秒時快進一步比較
            if(o.sec>sec){//秒時刻多輸出true
                return true;
            }
        }
        return false;//其餘全部狀況，都輸出false：沒有超過5min
    }
}

public class Solution {
    private static HashMap<String,Integer> hm=new HashMap();//統計頻次
    private static myDate staTime=null;//基準時刻

    public static void SinInput(String str){
        String time=str.substring(0,19);
        String intName=str.substring(20);

        myDate preDate=new myDate(time);

        if(staTime==null){
            staTime=preDate;
            hm.put(intName,1);//將這個數據添加進hm
            return;
        }

        if(!staTime.subDate(preDate)){//1,沒有超過5分鐘,直接在hashMap中添加或者累積
            if(hm.containsKey(intName)){//1,1hm中有原始的數據
                hm.put(intName,hm.get(intName)+1);
            }else {//1,2hm中沒有原始的數據
                hm.put(intName,1);
            }

        }else {//2,超過5分鐘，將本輪數據的 最大頻數及名稱輸出
            int num=0;
            String name="";
            for(String key:hm.keySet()){
                if(num<hm.get(key)){
                    name=key;
                    num=hm.get(key);
                }
            }
            System.out.println(num+" "+name);
            hm.clear();
            hm.put(intName,1);
        }
    }

    public static void FinWork(){//主動退出，而且處理，清空hm中剩餘數據
        int num=0;
        String name="";
        for(String key:hm.keySet()){
            if(num<hm.get(key)){
                name=key;
                num=hm.get(key);
            }
        }
        System.out.println(num+" "+name);
        hm.clear();
    }

    public static void main(String[] args) {
        //1,測試
        ArrayList<String> arr=new ArrayList<>();
        arr.add("2019-09-10T10:00:01 /api/a");
        arr.add("2019-09-10T10:00:01 /api/a");
        arr.add("2019-09-10T10:00:01 /api/b");
        arr.add("2019-09-10T10:06:00 /api/a");

        //2，輸入
        Scanner sc=new Scanner(System.in);

        //3，輸入&處理
        for(int i=0;i<arr.size();i++){
            SinInput(arr.get(i));
        }
        FinWork();//主動退出，並處理剩餘數據

    }
}
/*
2 /api/a
1 /api/a
 */

3，找出三子棋最有利的落點

　　有一種3x3大小的正方形棋盤，相似五子棋玩法橫豎斜着三種顏色相連就勝利，求出下一個棋子的最佳落點，默認黑子先手

　　咔咔，這個是一個二維的問題！直接在水平、豎直、斜向進行檢測，而且將檢測結構存於hashMap中，其實這裏能夠進一步推廣，變成動態的自動下棋軟件。

package com.cnblogs.mufasa.Main3;

import java.util.ArrayList;
import java.util.HashMap;

public class Solution {
    private static HashMap<Integer, ArrayList<int[]>> hm=new HashMap<>();

    public static void findX(int[][] map,int type){//直接橫向的進行遍歷
        int lenX=map.length;
        int lenY=map[0].length;

        ArrayList<int[]> arr=new ArrayList<>();
        int sum;
        for(int i=0;i<lenX;i++){
            sum=lenY;
            for(int j=0;j<lenY;j++){
                if(map[i][j]==-1*type){//1,1是另外顏色的落子，本行沒法取勝，直接清空數據跳出
                    arr.clear();
                    break;
                }else if(map[i][j]==type){//1,2是該顏色的落子，勝率加大
                    sum--;
                }else {//1,3是空位點，能夠落子
                    arr.add(new int[]{i,j});
                }
            }

            if(arr.size()!=0){//1,4有可能的位點
                if(hm.containsKey(sum)){//1,4,1原始hm中有相關sum數據
                    arr.addAll((ArrayList<int[]>)hm.get(sum).clone());
                    hm.put(sum,(ArrayList<int[]>)arr.clone());
                    arr.clear();
                }else {//1,4,2原始hm中沒有相關sum數據
                    hm.put(sum,(ArrayList<int[]>) arr.clone());
                    arr.clear();
                }
            }

        }
    }

    public static void findY(int[][] map,int type){//直接縱向的進行遍歷
        int lenX=map.length;
        int lenY=map[0].length;
        ArrayList<int[]> arr=new ArrayList<>();
        int sum;
        for(int i=0;i<lenX;i++){
            sum=lenY;
            for(int j=0;j<lenY;j++){
                if(map[j][i]==-1*type){//1,1是另外顏色的落子，本行沒法取勝
                    arr.clear();
                    break;
                }else if(map[j][i]==type){//1,2是該顏色的落子，勝率加大
                    sum--;
                }else {//1,3是空位點，能夠落子
                    arr.add(new int[]{j,i});
                }
            }

            if(arr.size()!=0){//1,4有可能的位點
                if(hm.containsKey(sum)){//1,4,1原始hm中有相關sum數據
                    arr.addAll((ArrayList<int[]>)hm.get(sum).clone());
                    hm.put(sum,(ArrayList<int[]>)arr.clone());
                    arr.clear();
                }else {//1,4,2原始hm中沒有相關sum數據
                    hm.put(sum,(ArrayList<int[]>) arr.clone());
                    arr.clear();
                }
            }

        }
    }

    public static void findZ(int[][] map,int type){//進行斜向的遍歷
        int lenX=map.length;
        int lenY=map[0].length;
        int len=Math.min(lenX,lenY);

        ArrayList<int[]> arr=new ArrayList<>();
        int sum=len;

        for(int i=0;i<len;i++){//左上至右下
            if(map[i][i]==-1*type){
                arr.clear();
                break;
            }else if(map[i][i]==type){
                sum--;
                if(sum==0){
                    break;
                }
            }else {
                arr.add(new int[]{i,i});
            }
        }

        if(arr.size()!=0){
            if(hm.containsKey(sum)){
                arr.addAll((ArrayList<int[]>)hm.get(sum).clone());
                hm.put(sum,(ArrayList<int[]>)arr.clone());
                arr.clear();
            }else {
                hm.put(sum,(ArrayList<int[]>) arr.clone());
            }
            arr.clear();
        }

        sum=len;
        for(int i=0;i<len;i++){//右上至左下
            if(map[i][len-1-i]==-1*type){
                arr.clear();
                break;
            }else if(map[i][len-1-i]==type){
                sum--;
                if(sum==0){
                    break;
                }
            }else {
                arr.add(new int[]{i,len-i-1});
            }
        }

        if(arr.size()!=0){
            if(hm.containsKey(sum)){
                arr.addAll((ArrayList<int[]>)hm.get(sum).clone());
                hm.put(sum,(ArrayList<int[]>)arr.clone());
                arr.clear();
            }else {
                hm.put(sum,(ArrayList<int[]>) arr.clone());
            }
            arr.clear();
        }
    }

    public static void toOut(int type){//數據輸出
        for(int i=0;i<=3;i++){
            if(hm.containsKey(i)){
                if(type==-1){
                    System.out.print("B:");
                }else {
                    System.out.print("W:");
                }
                for(int[] temp:hm.get(i)){
                    System.out.print("("+temp[0]+","+temp[1]+")");
                }
                System.out.println();
                hm.clear();
                break;
            }
        }
    }

    public static void main(String[] args) {

        //1，測試
        int[][] map=new int[][]{{0, 1, 0},
                                {0,-1, 0},
                                {0, 0, 0}};//-1表示黑子，1表示白子，0表示空位

        //2，輸入
//        Scanner sc=new Scanner(System.in);

        //3，處理輸出
        int bNum=0;
        int wNum=0;
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(map[i][j]==-1){
                    bNum++;
                }else if(map[i][j]==1){
                    wNum++;
                }
            }
        }

        int type=(bNum==wNum?-1:1);
        findX(map,type);
        findY(map,type);
        findZ(map,type);
        toOut(type);

    }
}