SRM 388 Level2 1000
          http://www.topcoder.com/stat?c=problem_statement&pm=8565&rd=11122
          給定N和K,返回N中最大素數因子小于等于K的數字個數

          解法與素數的計算流程相通
          自下向上,只是對每個數多記錄一次其最大素數因子
           1mport java.util.*;
           2import java.util.regex.*;
           3import java.text.*;
           4import java.math.*;
           5import java.awt.geom.*;
           6
           7public class SmoothNumbersHard
           8{
           9    public int countSmoothNumbers(int N, int k)
          10    {
          11        boolean[] prime = new boolean[N+1];
          12        int[] divider = new int[N+1];
          13        Arrays.fill(prime,true);
          14        Arrays.fill(divider, 1);
          15        for(int i = 2 ; i <= N; ++ i){
          16            if(prime[i]){
          17                divider[i] = i;
          18                for(int j = 2; i * j <= N; ++ j){
          19                    prime[i*j] = false;
          20                    divider[i*j] = i;
          21                }

          22            }

          23        }

          24        int ans = 0;
          25        for(int i = 1 ; i <= N ; ++ i){
          26            if(divider[i] <= k)
          27                ans++;
          28        }

          29        return ans;
          30    }

          31    
          posted @ 2009-11-08 19:54 jav7er 閱讀(67) | 評論 (0)編輯 收藏
           
          TopCoder SRM324  Level2 1000
          http://www.topcoder.com/stat?c=problem_statement&pm=6811&rd=10004
          給出n種商品不同顧客的購買選擇,計算打包組合的商品,即所有顧客要么都買要么都不買的組合,返回最小的打包數。

          最直接的想法就是遍歷一邊,每個顧客的數據分成不斷對當前的各個包取交和取減分為更小的包
          可是這樣的復雜度高達2的N次方,以案例的數據量50來看一定是超時的
          答案是將輸入從不同顧客的產品選擇轉化成為不同產品的購買顧客
          結果是直接比較兩種產品的就可以知道是否可以在同一個包中
          大大降低的復雜度
          只要能相通這一點
          后面的代碼是非常容易的
          posted @ 2009-11-07 19:42 jav7er 閱讀(68) | 評論 (0)編輯 收藏
           
          TopCoder SRM 375 Level2 950
          http://www.topcoder.com/stat?c=problem_statement&pm=8318&rd=10794
          給出一個數n,返回以n開頭的可以被n的每一位非零數字整除的數。

          題目本身暴力計算沒難度
          終點在于對有解性或者解的估計
          由于1~9的最小公倍數是2520
          所以在n0000到n2519中一定有一個數可以整除其所有位
          最多計算次數也就是1+10+100+1000+2520
          posted @ 2009-11-07 18:01 jav7er 閱讀(96) | 評論 (0)編輯 收藏
           
          TopCoder SRM 339 Level2 1000
          http://www.topcoder.com/stat?c=problem_statement&pm=7423&rd=10663
          N個車站,若干輛車,每輛車有始發、終點、開車時間、運行時間和票價5個參數,求從第一站到最后一站在T時間內最便宜的乘車方案。

          初看是很簡單的DP,只要用數組從第一行向后逐行計算即可
          可是后來看了測試數據發現了逆行車
          所以在計算順序上加了隊列 相當于是一個寬搜

          解決時候主要的問題出在了DP數組的定義上
          一開始的思路是用車站和車去開二維數組
          這樣的話每個值又要用時間和價格兩個參數去記錄
          計算過程也非常復雜
          后來經過提示改成用車站和時間去記錄價格
          就方便多了

           1import java.util.*;
           2import java.util.regex.*;
           3import java.text.*;
           4import java.math.*;
           5import java.awt.geom.*;
           6
           7public class OnTime
           8{
           9    //the queue has to record two dimensions 
          10    public class pair{
          11        int n;
          12        int t;
          13        public pair(int n, int t){
          14            this.n = n;
          15            this.t = t;
          16        }

          17    }

          18    
          19    public int minCost(int N, int T, String[] buses)
          20    {
          21        int L = buses.length;
          22        int[] a = new int[L];
          23        int[] b = new int[L];
          24        int[] depart = new int[L];
          25        int[] time = new int[L];
          26        int[] cost = new int[L];
          27        
          28        //data parse
          29        int i;
          30        for(i = 0; i < L; ++i){
          31            String temps = buses[i];
          32            String[] ints = temps.split(" ");
          33            a[i] = Integer.parseInt(ints[0]);
          34            b[i] = Integer.parseInt(ints[1]);
          35            depart[i] = Integer.parseInt(ints[2]);
          36            time[i] = Integer.parseInt(ints[3]);
          37            cost[i] = Integer.parseInt(ints[4]);
          38        }

          39        
          40        int[][] table = new int[N][T+1];
          41        for(int[] ta : table)
          42            Arrays.fill(ta, Integer.MAX_VALUE);
          43        table[0][0= 0;
          44        
          45        //first station is special
          46        Queue<pair> q = new LinkedList<pair>();
          47        for(i = 0 ; i < L; ++ i){
          48            if(a[i] == 0 && depart[i] >= 0 && depart[i]+time[i] <= T){
          49                table[b[i]][depart[i]+time[i]] = table[0][0+ cost[i];
          50                q.add(new pair(b[i],depart[i]+time[i]));
          51            }

          52        }

          53        
          54        //bfs search
          55        while(!q.isEmpty()){
          56            pair out = q.poll();
          57            for(i = 0; i < L; ++ i){
          58                if(a[i] == out.n && depart[i] > out.t && depart[i] + time[i] <=&&
          59                        cost[i] + table[out.n][out.t] < table[b[i]][depart[i]+time[i]]){
          60                    table[b[i]][depart[i]+time[i]] = table[out.n][out.t] + cost[i];
          61                    q.add(new pair(b[i],depart[i]+time[i]));
          62                }

          63            }

          64        }

          65        
          66        
          67        //find min 
          68        int min = table[N-1][0];
          69        for(i = 1 ; i <= T ; ++ i){
          70            if(table[N-1][i] < min)
          71                min = table[N-1][i];
          72        }

          73        
          74        
          75        return (min==Integer.MAX_VALUE?-1:min);
          76    
          77    }

          78}
          posted @ 2009-11-07 10:46 jav7er 閱讀(86) | 評論 (0)編輯 收藏
           
          TopCoder SRM 392 Level2 1000
          原題地址:http://www.topcoder.com/stat?c=problem_statement&pm=8561&rd=11126
          兩個整數n和d, 1<=n<=10, 1<=d<=n,求一個n*n方陣,每一行每一列都存在0~d的每個數,如果有多個矩陣,返回字母序最小的一個。

          從頭遞歸搜索,對每個位置從小遍歷所有值,針對每個值做如下操作:
          1.賦值為0
          2.檢查該行剩下的位置是否足夠放下還沒有出現的所有的數,若否返回第一步并且++;
          3.檢查該列剩下的位置是否足夠放下還沒有出現的所有的數,若否返回第一步并且++;
          4.現在是一個可以考慮的值,首先是終結值,若該位置已經是矩陣右下角,則返回true,這是唯一返回true的起點
          5.向后遞歸調用函數,調用下一個位置
          6.如果返回值為true,則返回true,否則繼續
          7.返回false

          總的來說,遞歸的順序,1是遍歷所有可能值,2,3是排除和剪枝,4是檢測成功條件,5是遞歸調用,6,7是遞歸的結果
          算法的復雜度較高,(15,15)就已經算不出了,而且還不知道該怎么計算時間復雜度,這樣的遞歸應該復雜度是很高的
          可是通過剪枝應該優化了很多,不過不知道計算復雜度時侯要怎么考慮。

          很大程度上還是根據提示寫完的,代碼能力太弱啦!
           1import java.util.*;
           2import java.util.regex.*;
           3import java.text.*;
           4import java.math.*;
           5import java.awt.geom.*;
           6
           7public class QuasiLatinSquares
           8{
           9    int[][] ans;
          10    int n;
          11    int d;
          12    
          13    public String[] makeSquare(int n, int d)
          14    {
          15        
          16        this.n = n;
          17        this.d = d;
          18        ans = new int[n][n];
          19        backtrace(0,0);
          20        
          21        //change the integer matrix to string array
          22        String[] ret = new String[n];
          23        for(int i = 0; i < n ; ++ i){
          24            StringBuilder sb = new StringBuilder();
          25            sb.append(ans[i][0]);
          26            for(int j = 1; j < n ; ++ j){
          27                sb.append(" ");
          28                sb.append(ans[i][j]);
          29            }

          30            ret[i] = sb.toString();
          31        }

          32        return ret;
          33    }

          34    
          35    public boolean backtrace(int i, int j){
          36        //have to check every value here
          37        for(int v = 0; v < d; ++ v){
          38            ans[i][j] = v;
          39            
          40            //check whether still enough place for numbers that haven't appear
          41            boolean[] row = new boolean[d];
          42            boolean[] col = new boolean[d];
          43            Arrays.fill(row, false);
          44            Arrays.fill(col, false);
          45            for(int rowidx = 0; rowidx <= i; ++ rowidx)
          46                row[ans[rowidx][j]] = true;
          47            for(int colidx = 0; colidx <= j; ++ colidx)
          48                col[ans[i][colidx]] = true;
          49            int rct = 0, cct = 0;
          50            for(boolean b:row){
          51                if(b == false) rct++;
          52            }

          53            for(boolean b:col){
          54                if(b == false) cct++;
          55            }

          56            if(rct > n-1-i)
          57                continue;
          58            if(cct > n-1-j)
          59                continue;
          60            
          61            //if it's the last place, success!
          62            if((i == n-1&& (j == n-1))
          63                return true;
          64
          65            //recursively calculate latter numbers based on this value
          66            boolean next;
          67            if(j != n-1)
          68                next = backtrace(i,j+1);
          69            else
          70                next = backtrace(i+1,0);
          71            //if it has reached the end,it means this value has led to success, else it means the value has to increase
          72            if(next == true)
          73                return true;
          74            
          75        }

          76        //have checked every number but none matches, former numbers has to reconsider
          77        return false;
          78    }

          79}
          posted @ 2009-11-03 21:21 jav7er 閱讀(101) | 評論 (0)編輯 收藏
          僅列出標題
          共2頁: 上一頁 1 2 
           
          主站蜘蛛池模板: 鄄城县| 衡阳县| 来宾市| 涞水县| 天峻县| 宁强县| 上饶县| 双桥区| 阿合奇县| 宣城市| 嵩明县| 宕昌县| 伊金霍洛旗| 东海县| 林甸县| 芜湖县| 庐江县| 淮安市| 乌兰浩特市| 象州县| 昌都县| 炉霍县| 长沙市| 大邑县| 柘城县| 明光市| 陕西省| 定西市| 资溪县| 青河县| 南乐县| 乌拉特前旗| 隆德县| 崇阳县| 游戏| 三明市| 南雄市| 榆树市| 南平市| 宜良县| 华蓥市|