guixunlong的专栏

Problem descriptioin: http://uva.onlinejudge.org/external/1/103.html 采用动态规划记忆化搜索（隐式图）实现 /* * 103.cc * * Created on: Dec 27, 2012 * Author: guixl */ #include #include #include usin

public class Solution { public int maxProfit(int[] prices) { // Start typing your Java solution below // DO NOT write main() function if (prices.length < 1) ret

动态规划记忆化搜索实现，时间复杂度应该小于O(N^3)，可以pass Judge Small public class Solution { public int maxProfit(int[] prices) { // Start typing your Java solution below // DO NOT write main() funct

先算出所有的赚钱区间,用一个列表存所有的购入时机，用另一个列表存所有的卖出时机。然后在这两个列表里取出两个买入节点，两个卖出节点，把收益最大化： public class Solution { public int maxProfit(int[] prices) { int in = -1; int index = -1; List buy

简单的编程题，响应题目要求，不用额外的存储空间 public class Solution { public ArrayList getRow(int rowIndex) { // Start typing your Java solution below // DO NOT write main() function ArrayLis

最简单的递归写法，可以pass Judge Small, TLE Judge Large public class Solution { public int minimumTotal(ArrayList> triangle) { // Start typing your Java solution below // DO NOT write main

简单的编程题 public class Solution { public ArrayList> generate(int numRows) { // Start typing your Java solution below // DO NOT write main() function ArrayList> result = new A

编程题，按层次遍历，利用一个分隔树节点进行层次的分隔 /** * Definition for binary tree with next pointer. * public class TreeLinkNode { * int val; * TreeLinkNode left, right, next; * TreeLinkNode(int x) { va

树的前序遍历算法： /** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class Solution

回溯实现： public class Solution { public int numDistinct(String S, String T) { // Start typing your Java solution below // DO NOT write main() function return work(S, T, 0,

题目很简单，需要注意的是在大dataset规模下的怎样让程序运行时间不超时 package Round_1_A; import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; import java.util.Scanner; public class Bullseye { /

本打算用类似于最长上升子序列的动态规划记忆化搜索实现，意外的竟然直接用回溯搜索就能pass Judge Large了，测试用例并不大是一个原因，还有就是子状态数可能要比想像中的要少。 public class Solution { public boolean isInterleave(String s1, String s2, String s3) { // Start

引用Wiki对线段树的介绍： 线段树（Segment Tree）是一种二叉搜索树，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左子树表示的区间为[a,(a+b)/2]，右子树表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树。叶节点数目为N，即整个线段区间的长度。 使用线段树可以快速的查找某

递归加记忆化搜索，PASS Large Judge /** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public

通过Large Judge还挺不容易 public class Solution { public boolean isPalindrome(String s) { int i=0, j=s.length()-1; while (i < j) { char ci=' ', cj=' '; while (i<j

Given an unsorted array of integers, find the length of the longest consecutive elements sequence. For example, Given [100, 4, 200, 1, 3, 2], The longest consecutive elements sequence is [1,

辗转相除法的详细介绍在这里：http://zh.wikipedia.org/wiki/%E8%BC%BE%E8%BD%89%E7%9B%B8%E9%99%A4%E6%B3%95#.E8.B4.9D.E7.A5.96.E7.AD.89.E5.BC.8F 简单来说，就是两个数a跟b的最大公约数gcd(a,b) = gcd(b, a%b),当b=0时，gcd(a,b) = a。 举例来说：

题目地址：http://uva.onlinejudge.org/external/100/10003.html 采用动态规划记忆化搜索实现，采用results二维数组存储中间计算结果 /*  * 10003.cc  *  *  Created on: Dec 28, 2012  *      Author: guixl  */ #include #include

如图1所示，为该图初始状态，绿色线条为正流量权重，灰色线条为反流量权重。在此算法中，每当正向流量减少N时，反向流量则增加N,反之亦然。 找到一条从s->t的路径：s->v1->v2->t，该路径的最大流量为2，则更新完流量以后的图如下图所示。 找到一条由s->t的路径：s->v1->t，该路径的流量限制为2,则更新完流量以后如下图所示： 找到另

基本思想： 每次从当前的最短路径中选出一个，并利用该节点优化图中起始点至图中其它各未访问到的节点的距离。以下图为例，我们欲求出起始点(A)至其它各节点的最短路径： 用数组D来存储A至其它各节点当前路短的距离，例如：D[1]为A-B的当前最短距离，D[2]为A-C当前最短距离。 起始状态为D[0]=0,根据图的连通关系，可以得到： D[1] = D[0]+L(0->1) =

Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。 这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。

题目描述：http://uva.onlinejudge.org/external/110/11078.html /* * 11078.cc * * Created on: Jan 22, 2013 * Author: guixl */ #include int max(int a, int b) { return a > b ? a : b; } int

题目描述： http://uva.onlinejudge.org/external/1/147.html 分析： 1.典型的动态规划题 2.注意浮点型向整数型强制转换的问题，比如299.90*100强制转换成整型可能为29989。小技巧是可以用(n+0.005)*100来解决 3.由于计算结果会超过int型表示范围，所以需要使用long long来保存结果，否则会得到WA

题目描述：http://uva.onlinejudge.org/external/5/567.html 典型的最短路径问题，采用dijkstra算法实现如下： /* * 567.cc * * Created on: Jan 8, 2013 * Author: root */ #include #include const int INF = 100;

题目描述：http://uva.onlinejudge.org/external/100/10034.html 典型的最小生成树算法，使用Kruskal算法实现 需要注意的是并查集的使用，查询、优化及合并操作 /* * 10034.cc * * Created on: Jan 8, 2013 * Author: root */ #include #incl

题目描述：http://uva.onlinejudge.org/external/3/357.html 最基础的动态规划，使用滚动数组优化后代码： /* * 357.cc * * Created on: Jan 9, 2013 * Author: guixl */ #include #define int64 long long int money

动态规划实现，用二维数组存储各个面朝上的情况 package Ch9; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { /** * @param args */ public static void main(

Problem Statement      Wolf Sothe is a member of the wolf pack called Grid Walkers. The N wolves in the pack are numbered 0 through N-1. (Wolf Sothe is the wolf number 0, but this does not matter.)

随机事件的信息熵：设随机变量ξ，它有A1，A2，A3，A4，……，An共n种可能的结局，每个结局出现的概率分别为p1，p2，p3，p4，……，pn，则其不确定程度，即信息熵为: 举例：抛硬币 p(head) = 0.5, p(tail) = 0.5 信息熵为H(p) = -(0.5 * log(0.5) * 2) = -log0.5 = 1(log以2为底)