Showing posts with label Knapsack - Mixed. Show all posts
Showing posts with label Knapsack - Mixed. Show all posts

HDU 2159 Fate


Problem - 2159
最近xhd正在玩一款叫做FATE的游戏,为了得到极品装备,xhd在不停的杀怪做任务。久而久之xhd开始对杀怪产生的厌恶感,但又不得不通过杀怪来升完这最后一级。现在的问题是,xhd升掉最后一级还需n的经验值,xhd还留有m的忍耐度,每杀一个怪xhd会得到相应的经验,并减掉相应的忍耐度。当忍耐度降到0或者0以下时,xhd就不会玩这游戏。xhd还说了他最多只杀s只怪。请问他能升掉这最后一级吗?

Input
输入数据有多组,对于每组数据第一行输入n,m,k,s(0 < n,m,k,s < 100)四个正整数。分别表示还需的经验值,保留的忍耐度,怪的种数和最多的杀怪数。接下来输入k行数据。每行数据输入两个正整数a,b(0 < a,b < 20);分别表示杀掉一只这种怪xhd会得到的经验值和会减掉的忍耐度。(每种怪都有无数个)

Output
输出升完这级还能保留的最大忍耐度,如果无法升完这级输出-1。

Sample Input
10 10 1 10 1 1 10 10 1 9 1 1 9 10 2 10 1 1 2 2
Sample Output
0 -1 1
限制条件: 1.忍耐度 m   2.杀怪个数 s
http://www.cnblogs.com/dongsheng/archive/2012/08/22/2651614.html
 4 int dp[101][101];      //dp[i][j] 表示消耗i的忍耐度和杀j个怪物得到的最大经验值
 5 struct node
 6 {
 7     int e;     //经验值
 8     int r;     //忍耐度
 9 }a[101];
10 
11 int main()
12 {
13     int n,m,k,s,i,j,t;
14     while(scanf("%d%d%d%d",&n,&m,&k,&s)!=EOF)
15     {
16         for(i=1;i<=k;++i)
17             scanf("%d%d",&a[i].e,&a[i].r);
18         memset(dp,0,sizeof(dp));
19         for(i=1;i<=k;++i)   //k表示怪物种类---对不同怪物遍历一遍
20             for(j=a[i].r;j<=m;++j)  //m表示保留的忍耐度
21                 for(t=1;t<=s;++t)    // s表示杀的怪物数
22                 {
23                     if(dp[j][t]<dp[j-a[i].r][t-1]+a[i].e)
24                     {
25                         dp[j][t]=dp[j-a[i].r][t-1]+a[i].e;
26                     }
27                 }
28         if(dp[m][s]>=n)     //表示能过升级
29         {
30                 for(i=0;i<=m;++i)   //寻找能够升级所消耗的最小忍耐度,只用找消耗相同忍耐度的情况下,令杀怪数量最多,
31                     if(dp[i][s]>=n) //那么d[i][s]一定是消耗i忍耐度的情况下,获得的最大经验值
32                     {
33                         printf("%d\n",m-i);
34                         break;
35                     }
36         }
37         else
38             printf("-1\n");
39     }
40     return 0;
41 }
https://www.jianshu.com/p/1f2aa01a7149
    while(scanf("%d%d%d%d",&n,&m,&k,&s)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;i++)
        {
            scanf("%d%d",exp+i,cost+i);
        }
        for(int i=1;i<=k;i++)
        {
            for(int j=1;j<=s;j++)
            {
                for(int q=cost[i];q<=m;q++)
                {
                    dp[j][q]=Max(dp[j][q],dp[j-1][q-cost[i]]+exp[i]);
                }
            }
        }
        if(dp[s][m]<n)
        {
            printf("-1\n");
        }
        else
        {
            int tmp=0;
            for(int i=1;i<=m;i++)
            {
                if(dp[s][i]>=n)
                {
                    tmp=i;
                    break;
                }
            }
            printf("%d\n",m-tmp);
        }
    }

}
http://blog.csdn.net/u013476556/article/details/38349831
dp[j][k]的意思的是  在忍耐度为j,杀了k个怪的状态下所对应的经验值。
dp[j-wei[i]][k-1] + val[i];在忍耐度为  j - wei[i],杀了k-1个怪的状态下所对应的经验值。
第三个for循环正序逆序都会AC  。。
  1.    while(scanf("%d%d%d%d",&n,&m,&k,&s)!=EOF)///经验值 忍耐度 种类 杀怪数  
  2.     {  
  3.         for(int i=0; i<k; i++)  
  4.         {  
  5.             scanf("%d%d",&val[i],&wei[i]);  
  6.         }  
  7.         memset(dp,0,sizeof(dp));  
  8.         for(int i = 0; i < k; i++) ///种类  
  9.         {  
  10.             for(int j = wei[i]; j <= m; j++) ///忍耐度  
  11.             {  
  12.                 for(int k = s; k >= 1; k--) ///杀怪数  
  13.                 {  
  14.                     dp[j][k] = Max(dp[j][k],dp[j-wei[i]][k-1] + val[i]);///在忍耐度为j,杀了k个怪的状态下所对应的经验值  
  15.                 }  
  16.             }  
  17.         }  
  18.         int i;  
  19.         for (i =0 ;i <= m; i++)  
  20.         {  
  21.             if (dp[i][s] >= n)  
  22.                 break;  
  23.         }  
  24.         if (i > m)  
  25.             printf ("-1\n");  
  26.         else printf ("%d\n",m - i);  
  27.     }  

http://www.programerhome.com/?p=4537
思路:这题是一道典型的二维完全背包题,背包内所要储存的是经验,所以背包的容量便以忍耐度与杀怪数作为标准,每次得到背包价值的最大数与升级所需的经验作比较,能够升级就退出。
    while(cin>>n>>m>>k>>s)//经验值,忍耐度,怪的种数和最多杀怪数
    {
        for(int i=1; i<=k; ++i)
            cin>>a[i].v>>a[i].w;

        memset(dp, 0, sizeof(dp));

        for(x=1; x<=m; x++)
        {
            for(y=1; y<=k; ++y)
                for(z=1; z<=s; ++z)
                {
                    int st=1;
                    while(st*a[y].w<=x&&st<=z)
                    {
                        dp[x][z]=max(dp[x-st*a[y].w][z-st]+st*a[y].v,dp[x][z]);
                        st++;
                    }

                }
            if(dp[x][s]>=n)
                break;
        }
        if(x>m)
            cout<<-1<<endl;
        else
            cout<<m-x<<endl;

    }
http://blog.csdn.net/zfz1015/article/details/7854788


Read full article from Problem - 2159

ZOJ 3164 :: Problems :: Show Problem


ZOJ :: Problems :: Show Problem
MM enjoyed cookies very much. On Saint Valentine's Day, when she stepped into a big cookie store again, she wouldn't leave unless DD spent all his money in pocket!
There are N kinds of cookies, labeled from 1 to N, and all can be bought without any restriction by the store. But actually, for some kinds of cookies, MM wanted to buy one piece at most, and for some kinds of cookies, MM wanted to buy Ki pieces at most, and for some other kinds of cookies, there didn't exist an upper bound that MM wanted to buy.
There is another requirement from MM: there are some groups of cookies, MM considered their tastes similar, so she wanted to buy at most one kind of cookies in each group. A kind of cookie wouldn't appear in more than one group.
For the ith kind of cookies, MM has an "enjoyable value" Ei, if DD bought Ai pieces of this kind for her, and Ai didn't exceed her upper bound, MM get EiAi of enjoyable value. After buying cookies, MM's total enjoyable value will be the sum of EiAi.
But actually, poor DD had only D dollars, and the price for the ith kind of cookies is Pi dollars per piece. DD must spend all his D dollars to buy cookies, to meet requirements about amount and taste from MM, and to make MM's enjoyable value as high as possible. What's more, as you know, a legal plan's enjoyable value must be non-negative.
Input
There are multiple test cases. Each test case consists of three parts.
The first part is one line with two integers N and D.
The second part has N lines, line i consists of three integers Ki, Ei and Pi. If Ki equals to 0, it means for ith kind of cookies, there didn't exist an upper bound that MM wanted to buy, otherwise Ki is the upper bound for ith kind of cookies.
The third part describes the groups. A non-negative integer G represents the number of groups, and then G lines, each line consists of some integers represents labels of kinds of cookies in this group.
One blank line between test cases.
Output
If the proper and optimal plan exists, output the maximal total enjoyable value ΣEiAi, otherwise output "i'm sorry...".

Read full article from ZOJ :: Problems :: Show Problem

Knapsack - Mixed P04: 混合三种背包问题


P04: 混合三种背包问题
如果将P01、P02、P03混合起来。也就是说,有的物品只可以取一次(01背包),有的物品可以取无限次(完全背包),有的物品可以取的次数有一个上限(多重背包)。应该怎么求解呢?

01背包与完全背包的混合

考虑到在P01和P02中给出的伪代码只有一处不同,故如果只有两类物品:一类物品只能取一次,另一类物品可以取无限次,那么只需在对每个物品应用转移方程时,根据物品的类别选用顺序或逆序的循环即可,复杂度是O(VN)。伪代码如下:
for i=1..N     if 第i件物品属于01背包         for v=V..0             f[v]=max{f[v],f[v-c[i]]+w[i]};     else if 第i件物品属于完全背包         for v=0..V             f[v]=max{f[v],f[v-c[i]]+w[i]}; 

再加上多重背包

如果再加上有的物品最多可以取有限次,那么原则上也可以给出O(VN)的解法:遇到多重背包类型的物品用单调队列解即可。但如果不考虑超过NOIP范围的算法的话,用P03中将每个这类物品分成O(log n[i])个01背包的物品的方法也已经很优了。
当然,更清晰的写法是调用我们前面给出的三个相关过程。
for i=1..N     if 第i件物品属于01背包         ZeroOnePack(c[i],w[i])     else if 第i件物品属于完全背包         CompletePack(c[i],w[i])     else if 第i件物品属于多重背包         MultiplePack(c[i],w[i],n[i]) 
在最初写出这三个过程的时候,可能完全没有想到它们会在这里混合应用。我想这体现了编程中抽象的威力。如果你一直就是以这种"抽象出过程"的方式写每一类背包问题的,也非常清楚它们的实现中细微的不同,那么在遇到混合三种背包问题的题目时,一定能很快想到上面简洁的解法,对吗?

Read full article from P04: 混合三种背包问题

POJ 3260 The Fewest Coins【完全背包+多重背包】 - AndreMouche - 博客园


http://poj.org/problem?id=3260
Farmer John has gone to town to buy some farm supplies. Being a very efficient man, he always pays for his goods in such a way that the smallest number of coins changes hands, i.e., the number of coins he uses to pay plus the number of coins he receives in change is minimized. Help him to determine what this minimum number is.
FJ wants to buy T (1 ≤ T ≤ 10,000) cents of supplies. The currency system has N (1 ≤ N ≤ 100) different coins, with values V1, V2, ..., VN (1 ≤ Vi ≤ 120). Farmer John is carrying C1 coins of value V1, C2 coins of value V2, ...., and CN coins of value VN (0 ≤ Ci ≤ 10,000). The shopkeeper has an unlimited supply of all the coins, and always makes change in the most efficient manner (although Farmer John must be sure to pay in a way that makes it possible to make the correct change).
Input
Line 1: Two space-separated integers: N and T.
Line 2: N space-separated integers, respectively V1, V2, ..., VN coins (V1, ...VN)
Line 3: N space-separated integers, respectively C1, C2, ..., CN
Output
Line 1: A line containing a single integer, the minimum number of coins involved in a payment and change-making. If it is impossible for Farmer John to pay and receive exact change, output -1.
背包问题--POJ 3260 The Fewest Coins【完全背包+多重背包】 - AndreMouche - 博客园
题意:John去买东西,东西的价格是T(1 <= T <= 10000),John所在的地方有n(1 <= n <= 100)种的硬币,面值分别为V1, V2, ..., Vn (1 <= Vi <= 120)。John带了C1枚面值为V1的硬币,C2枚面值为V2的硬币,...,Cn枚面值为Vn的硬币(0 <= Ci <= 10000)。售货员那里每种硬币都有无限多个。问为了支付这个T,John给售货员的硬币数目加上售货员找回的零钱的硬币数目最少是多少。如果无法支付 T,输出-1 。

解法:支付时硬币数量有限制,为多重背包问题,通过二进制方法转化为01背包求解。找零时,硬币数量无限制,为完全背包问题。对两问题分别求解,然后找出差额为T时,两者和的最小值即为所示。

其中:给钱上界为:T+maxValue^2,其中maxValue为最大硬币面值。证明:反证法。假设存在一种支付方案,John给的钱超过 T+maxValue^2, 则售货员找零超过maxValue^2,则找的硬币数目超过maxValue个,将其看作一数列,求前n项和sum(n),根据鸽巢原理,至少有两 个对maxValue求模的值相等,假设为sum(i)和sum(j),i<j,则i+1...j的硬币面值和为 maxValue的倍数,同理,John给的钱中也有 一定数量的硬币面值和为maxValue的倍数,则这两堆硬币可用数量更少的maxValue面值硬币代替,产生更优方案。

分析:1.给钱时,硬币数有限制,为多重背包问题。
  2.找钱时,硬币数无限制,为完全背包问题。
  3.给钱上界为:T+maxValue^2,其中maxValue为最大硬币面值。证明:反证法。假设存在一种支付方案,John给的钱超过T+maxValue^2,
    则售货员找零超过maxValue^2,则找的硬币数目超过maxValue个,将其看作一数列,求前n项和sum(n),根据鸽巢原理,至少有两
    个对maxValue求模的值相等,假设为sum(i)和sum(j),i<j,则i+1j的硬币面值和为maxValue的倍数,同理,John给的钱中也有
    一定数量的硬币面值和为maxValue的倍数,则这两堆硬币可用数量更少的maxValue面值硬币代替,产生更优方案。

http://www.cnblogs.com/xcw0754/p/4493874.html

支付时硬币数量有限制,为多重背包问题,通过二进制方法转化为01背包求解。找零时,硬币数量无限制,为完全背包问题。对两问题分别求解,然后找出差额为T时,两者和的最小值即为所示。
FJ身上有各种硬币,但是要买m元的东西,想用最少的硬币个数去买,且找回的硬币数量也是最少(老板会按照最少的量自动找钱),即掏出的硬币和收到的硬币个数最少。
思路:老板会自动找钱,且按最少的找,硬币数量也不限,那么可以用完全背包得出组成每个数目的硬币最少数量。而FJ带的钱是有限的,那么必须用多重背包,因为掏出的钱必须大于m,那么我们所要的是大于等于m钱的硬币个数,但是FJ带的钱可能很多,超过m的很多倍都可能,那么肯定要有个背包容量上限,网上说的根据抽屉原理是m+max*max,这里的max指的是最大面值。而给多了的钱上限是max*max,那么找回的钱也必须是max*max,所以完全背包部分的背包容量是max*max。穷举这max*max个可能就行了。

我的思路:与上面不同的是多重背包的容量应该是m+max,因为如果需要找回的钱大于max,那么老板也只是拿多几张最大面额的给你而已。比如买条烟1329块钱,13+1+1+4=19张RMB, 那么我们可以给他14张,15张,16张,17张,18张100的,老板会相应找回71块,171块,271块,371块,471块,你再往上加钱的话,老板也只是拿更多的100还你,这是多余的。那么最多不会超过一张一百(最大面额)的,也就是1329+100=1429为背包容量。错了很多次!
http://www.cppblog.com/Davidlrzh/articles/135614.html
int main() 26{ 27    int N,T,n; 28    int maxV,maxT,minC; 29 30    while(cin>>N>>T) 31    { 32        maxV = 0; 33        for(int i=1; i<=N; i++) 34        { 35            cin>>V[i]; 36            if(maxV < V[i])                //找出最大面值硬币
 37            { 38                maxV = V[i]; 39            }
 40        }

 41        maxV *= maxV; 42        maxT = T + maxV;                   //给钱的上界maxT=T+max_Value^2
 43        for(int i=1; i<=N; i++) 44        { 45            cin>>C[i]; 46        }
 47 48        n = 0; 49        for(int i=1; i<=N; i++)                   //二进制方法,将多重背包问题转化为01背包问题
 50        { 51            for(int j=0; (1<<j)<=C[i]; j++) 52            { 53                ++n; 54                dV[n][1] = 1<<j; 55                dV[n][0] = dV[n][1] * V[i]; 56            }
 57            if(C[i] > 1) 58            { 59                dV[n][1] = C[i] - dV[n][1] + 1; 60                dV[n][0] = dV[n][1] * V[i]; 61            }
 62        }

 63 64        for(int j=0; j<=maxV; j++)                //找零dp过程,完全背包
 65        { 66            dpC[j] = INF; 67        }
 68        dpC[0] = 0; 69        for(int i=1; i<=N; i++) 70        { 71            for(int j=V[i]; j<maxV; j++)          //从小到大
 72            { 73                if(dpC[j] > dpC[j-V[i]] + 1) 74                { 75                    dpC[j] = dpC[j-V[i]] + 1; 76                }
 77            }

 78        }

 79         80        for(int j=0; j<=maxT; j++)                //给钱dp过程,01背包
 81        { 82            dpF[j] = INF; 83        }
 84        dpF[0] = 0; 85 86        for(int i=1; i<=n; i++) 87        { 88            for(int j=maxT; j>=dV[i][0]; j--)     //从大到小
 89            { 90                if(dpF[j] > dpF[j-dV[i][0]] + dV[i][1]) 91                { 92                    dpF[j] = dpF[j-dV[i][0]] + dV[i][1]; 93                }
 94            }

 95        }

 96 97        minC = INF; 98        for(int j=T; j<=maxT; j++)                //两个最小之和为所求
 99        {100            if(minC > dpF[j] + dpC[j-T])101            {102                minC = dpF[j] + dpC[j-T];103            }
104        }

105        if(minC != INF)106        {107            cout<<minC<<endl;108        }
109        else
110        {111            cout<<"-1"<<endl;112        }
113    }

114    return 0;115}

Read full article from 背包问题--POJ 3260 The Fewest Coins【完全背包+多重背包】 - AndreMouche - 博客园

Labels

LeetCode (1432) GeeksforGeeks (1122) LeetCode - Review (1067) Review (882) Algorithm (668) to-do (609) Classic Algorithm (270) Google Interview (237) Classic Interview (222) Dynamic Programming (220) DP (186) Bit Algorithms (145) POJ (141) Math (137) Tree (132) LeetCode - Phone (129) EPI (122) Cracking Coding Interview (119) DFS (115) Difficult Algorithm (115) Lintcode (115) Different Solutions (110) Smart Algorithm (104) Binary Search (96) BFS (91) HackerRank (90) Binary Tree (86) Hard (79) Two Pointers (78) Stack (76) Company-Facebook (75) BST (72) Graph Algorithm (72) Time Complexity (69) Greedy Algorithm (68) Interval (63) Company - Google (62) Geometry Algorithm (61) Interview Corner (61) LeetCode - Extended (61) Union-Find (60) Trie (58) Advanced Data Structure (56) List (56) Priority Queue (53) Codility (52) ComProGuide (50) LeetCode Hard (50) Matrix (50) Bisection (48) Segment Tree (48) Sliding Window (48) USACO (46) Space Optimization (45) Company-Airbnb (41) Greedy (41) Mathematical Algorithm (41) Tree - Post-Order (41) ACM-ICPC (40) Algorithm Interview (40) Data Structure Design (40) Graph (40) Backtracking (39) Data Structure (39) Jobdu (39) Random (39) Codeforces (38) Knapsack (38) LeetCode - DP (38) Recursive Algorithm (38) String Algorithm (38) TopCoder (38) Sort (37) Introduction to Algorithms (36) Pre-Sort (36) Beauty of Programming (35) Must Known (34) Binary Search Tree (33) Follow Up (33) prismoskills (33) Palindrome (32) Permutation (31) Array (30) Google Code Jam (30) HDU (30) Array O(N) (29) Logic Thinking (29) Monotonic Stack (29) Puzzles (29) Code - Detail (27) Company-Zenefits (27) Microsoft 100 - July (27) Queue (27) Binary Indexed Trees (26) TreeMap (26) to-do-must (26) 1point3acres (25) GeeksQuiz (25) Merge Sort (25) Reverse Thinking (25) hihocoder (25) Company - LinkedIn (24) Hash (24) High Frequency (24) Summary (24) Divide and Conquer (23) Proof (23) Game Theory (22) Topological Sort (22) Lintcode - Review (21) Tree - Modification (21) Algorithm Game (20) CareerCup (20) Company - Twitter (20) DFS + Review (20) DP - Relation (20) Brain Teaser (19) DP - Tree (19) Left and Right Array (19) O(N) (19) Sweep Line (19) UVA (19) DP - Bit Masking (18) LeetCode - Thinking (18) KMP (17) LeetCode - TODO (17) Probabilities (17) Simulation (17) String Search (17) Codercareer (16) Company-Uber (16) Iterator (16) Number (16) O(1) Space (16) Shortest Path (16) itint5 (16) DFS+Cache (15) Dijkstra (15) Euclidean GCD (15) Heap (15) LeetCode - Hard (15) Majority (15) Number Theory (15) Rolling Hash (15) Tree Traversal (15) Brute Force (14) Bucket Sort (14) DP - Knapsack (14) DP - Probability (14) Difficult (14) Fast Power Algorithm (14) Pattern (14) Prefix Sum (14) TreeSet (14) Algorithm Videos (13) Amazon Interview (13) Basic Algorithm (13) Codechef (13) Combination (13) Computational Geometry (13) DP - Digit (13) LCA (13) LeetCode - DFS (13) Linked List (13) Long Increasing Sequence(LIS) (13) Math-Divisible (13) Reservoir Sampling (13) mitbbs (13) Algorithm - How To (12) Company - Microsoft (12) DP - Interval (12) DP - Multiple Relation (12) DP - Relation Optimization (12) LeetCode - Classic (12) Level Order Traversal (12) Prime (12) Pruning (12) Reconstruct Tree (12) Thinking (12) X Sum (12) AOJ (11) Bit Mask (11) Company-Snapchat (11) DP - Space Optimization (11) Dequeue (11) Graph DFS (11) MinMax (11) Miscs (11) Princeton (11) Quick Sort (11) Stack - Tree (11) 尺取法 (11) 挑战程序设计竞赛 (11) Coin Change (10) DFS+Backtracking (10) Facebook Hacker Cup (10) Fast Slow Pointers (10) HackerRank Easy (10) Interval Tree (10) Limited Range (10) Matrix - Traverse (10) Monotone Queue (10) SPOJ (10) Starting Point (10) States (10) Stock (10) Theory (10) Tutorialhorizon (10) Kadane - Extended (9) Mathblog (9) Max-Min Flow (9) Maze (9) Median (9) O(32N) (9) Quick Select (9) Stack Overflow (9) System Design (9) Tree - Conversion (9) Use XOR (9) Book Notes (8) Company-Amazon (8) DFS+BFS (8) DP - States (8) Expression (8) Longest Common Subsequence(LCS) (8) One Pass (8) Quadtrees (8) Traversal Once (8) Trie - Suffix (8) 穷竭搜索 (8) Algorithm Problem List (7) All Sub (7) Catalan Number (7) Cycle (7) DP - Cases (7) Facebook Interview (7) Fibonacci Numbers (7) Flood fill (7) Game Nim (7) Graph BFS (7) HackerRank Difficult (7) Hackerearth (7) Inversion (7) Kadane’s Algorithm (7) Manacher (7) Morris Traversal (7) Multiple Data Structures (7) Normalized Key (7) O(XN) (7) Radix Sort (7) Recursion (7) Sampling (7) Suffix Array (7) Tech-Queries (7) Tree - Serialization (7) Tree DP (7) Trie - Bit (7) 蓝桥杯 (7) Algorithm - Brain Teaser (6) BFS - Priority Queue (6) BFS - Unusual (6) Classic Data Structure Impl (6) DP - 2D (6) DP - Monotone Queue (6) DP - Unusual (6) DP-Space Optimization (6) Dutch Flag (6) How To (6) Interviewstreet (6) Knapsack - MultiplePack (6) Local MinMax (6) MST (6) Minimum Spanning Tree (6) Number - Reach (6) Parentheses (6) Pre-Sum (6) Probability (6) Programming Pearls (6) Rabin-Karp (6) Reverse (6) Scan from right (6) Schedule (6) Stream (6) Subset Sum (6) TSP (6) Xpost (6) n00tc0d3r (6) reddit (6) AI (5) Abbreviation (5) Anagram (5) Art Of Programming-July (5) Assumption (5) Bellman Ford (5) Big Data (5) Code - Solid (5) Code Kata (5) Codility-lessons (5) Coding (5) Company - WMware (5) Convex Hull (5) Crazyforcode (5) DFS - Multiple (5) DFS+DP (5) DP - Multi-Dimension (5) DP-Multiple Relation (5) Eulerian Cycle (5) Graph - Unusual (5) Graph Cycle (5) Hash Strategy (5) Immutability (5) Java (5) LogN (5) Manhattan Distance (5) Matrix Chain Multiplication (5) N Queens (5) Pre-Sort: Index (5) Quick Partition (5) Quora (5) Randomized Algorithms (5) Resources (5) Robot (5) SPFA(Shortest Path Faster Algorithm) (5) Shuffle (5) Sieve of Eratosthenes (5) Strongly Connected Components (5) Subarray Sum (5) Sudoku (5) Suffix Tree (5) Swap (5) Threaded (5) Tree - Creation (5) Warshall Floyd (5) Word Search (5) jiuzhang (5)

Popular Posts