小呀嘛小二郎啊


  • 首页

  • 关于

  • 标签

  • 分类

  • 归档

leetcode之两数相加

发表于 2019-12-04 | 分类于 算法 |

一、题目

给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。

如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外,这两个数都不会以 0 开头。

示例:

输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出:7 -> 0 -> 8
原因:342 + 465 = 807

二、实现

public class ListNode {

public int val;
public ListNode next;
public ListNode(int val){
    this.val = val;
}

}

public class AddNumByListNode {

public static void main(String[] args) {
    ListNode l1 = new ListNode(2);
    l1.next = new ListNode(4);
    l1.next.next = new ListNode(3);

    ListNode l2 = new ListNode(5);
    l2.next = new ListNode(6);
    l2.next.next = new ListNode(4);

    ListNode result = addTwoNumbers(l1, l2);
    System.out.println(result.val);

}

public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode root = new ListNode(0);
    ListNode cursor = root;
    int carry = 0;
    while(l1 != null || l2 != null || carry != 0){
        int l1Val = l1 != null ? l1.val : 0;
        int l2Val = l2 != null ? l2.val : 0;
        int sumVal = l1Val + l2Val + carry;
        carry = sumVal / 10;
        ListNode sumNode = new ListNode(sumVal % 10);
        cursor.next = sumNode;
        cursor = sumNode;
        if(l1 != null){
            l1 = l1.next;
        }
        if(l2 != null){
            l2 = l2.next;
        }
    }
    return root.next;
}

}

批量转换Java源代码编码格式

发表于 2018-11-26 | 分类于 Java |

public class GBKForUTF8 {

public static final List filePathLists = new ArrayList();

/**

  • @param inEncoding 原编码格式
  • @param outEncoding 目标编码格式
  • @param inFileName 原文件路径
  • @param outFileName 目标文件路径
  • @throws IOException
    */
    public static void changeEncoding(String inEncoding, String outEncoding, String inFileName, String outFileName)
    ​ throws IOException {
    File file = new File(outFileName);
    if(!file.exists()){
    ​ file.createNewFile();
    }
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inFileName), inEncoding));
    BufferedWriter writer = new BufferedWriter(
    ​ new OutputStreamWriter(new FileOutputStream(outFileName), outEncoding));
    String line = null;
    while ((line = reader.readLine()) != null) {
    ​ writer.write(line, 0, line.length());
    ​ writer.newLine();
    }
    writer.flush();
    writer.close();
    reader.close();
    }

/**

  • @decription 将根目录下所有文件列出
  • @param path 原根目录路径
    */
    public static void getFilePath(String path) {
    File file = new File(path);
    if (file.exists()) {
    ​ File[] files = file.listFiles();
    ​ for (int i = 0; i < files.length; i++) {
    ​ if(files[i].isFile()){
    ​ filePathLists.add(files[i].getAbsolutePath());
    ​ }
    ​ if(files[i].isDirectory()){
    ​ getFilePath(files[i].getAbsolutePath());
    ​ }
    ​ }
    }
    }

/**

  • @description 创建目标文件夹下不存在的文件
  • @param path 单个文件路径
  • @throws IOException
    */
    public static void createFile(String path) throws IOException{
    String[] paths = path.split(“\\“);
    String str = paths[0];
    for(int i = 1; i < paths.length; i++){
    ​ str += “\“ + paths[i];
    ​ File file = new File(str);
    ​ if(!file.exists()){
    ​ if(i == paths.length - 1){
    ​ file.createNewFile();
    ​ }else{
    ​ file.mkdir();
    ​ }
    ​ }
    }
    }

Web学习

发表于 2018-11-14 | 分类于 web前端 |

动态规划算法

发表于 2018-09-08 | 分类于 算法 |

一、基本概念

​ 动态规划过程是:每次决策依赖于当前状态,又随即引起状态的转移。一个决策序列就是在变化的状态中生产出来的,所以,这样的多阶层最优化决策解决这个问题的过程就称为动态规划。

二、动态规划算法的基本思想

​ 只要问题可以划分成规模更小的子问题,并且原问题的最优解中包含了子问题的最优解,则可以考虑用动态规划解决。动态规划的实质是分治思想和解决冗余,因此,动态规划是一种将问题实例分解为更小的、相似的子问题,并存储子问题的解而避免计算重复的子问题,以解决最优化问题的算法策略。

​ 动态规划法与分治法和贪心法类似,它们都是将问题实例归纳为更小的、相似的子问题,并通过求解子问题产生一个全局最优解。其中贪心法的当前选择可能要依赖已经作出的所有选择,但不依赖于有待于做出的选择和子问题。因此贪心法自顶向下,一步一步地作出贪心选择;而分治法中的各个子问题是独立的 (即不包含公共的子子问题),因此一旦递归地求出各子问题的解后,便可自下而上地将子问题的解合并成问题的解。

​ 与分治法和贪心法不同的是,动态规划允许这些子问题不独立,也允许其通过自身子问题的解作出选择,该方法对每一个子问题只解一次,并将结果保存起来,避免每次碰到时都要重复计算。因此,动态规划法所针对的问题有一个显著的特征,即它所对应的子问题树中的子问题呈现大量的重复。动态规划法的关键就在于,对于重复出现的子问题,只在第一次遇到时加以求解,并把答案保存起来,让以后再遇到时直接引用,不必重新求解。

三、适用的情况

​ 能採用动态规划求解的问题的一般要具有3个性质:

​ (1)、最优化原理:假设问题的最优解所包括的子问题的解也是最优的,就称该问题具有最优子结构,即满足最优化原理。

​ (2)、无后效性:即某阶段状态一旦确定。就不受这个状态以后决策的影响。也就是说,某状态以后的过程不会影响曾经的状态。仅仅与当前状态有关;

​ (3)、有重叠子问题:即子问题之间是不独立的,一个子问题在下一阶段决策中可能被多次使用到(该性质并非动态规划适用的必要条件,可是假设没有这条性质。动态规划算法同其它算法相比就不具备优势)。

四、求解的基本步骤

​ 动态规划所处理的问题是一个多阶段决策问题,一般由初始状态开始,通过对中间阶段决策的选择,达到结束状态。这些决策形成了一个决策序列,同时确定了完成整个过程的一条活动路线(通常是求最优的活动路线)。如图所示。动态规划的设计都有着一定的模式,一般要经历以下几个步骤。

​ 初始状态→│决策1│→│决策2│→…→│决策n│→结束状态

​ (1)划分阶段:按照问题的时间或空间特征,把问题分为若干个阶段。在划分阶段时,注意划分后的阶段一定要是有序的或者是可排序的,否则问题就无法求解;

​ (2)确定状态和状态变量:将问题发展到各个阶段时所处于的各种客观情况用不同的状态表示出来。当然,状态的选择要满足无后效性;

​ (3)确定决策并写出状态转移方程:因为决策和状态转移有着天然的联系,状态转移就是根据上一阶段的状态和决策来导出本阶段的状态。所以如果确定了决策,状态转移方程也就可写出。但事实上常常是反过来做,根据相邻两个阶段的状态之间的关系来确定决策方法和状态转移方程;

​ (4)寻找边界条件:给出的状态转移方程是一个递推式,需要一个递推的终止条件或边界条件。

​ 一般,只要解决问题的阶段、状态和状态转移决策确定了,就可以写出状态转移方程(包括边界条件)。

​ 实际应用中可以按以下几个简化的步骤进行设计:

​ (1)分析最优解的性质,并刻画其结构特征;

​ (2)递归的定义最优解;

​ (3)以自底向上或自顶向下的记忆化方式(备忘录法)计算出最优值;

​ (4)根据计算最优值时得到的信息,构造问题的最优解。

五、经典题目

爬楼梯问题

题目描述:有 N 阶楼梯,每次可以上一阶或者两阶,求有多少种上楼梯的方法。

定义一个数组 dp 存储上楼梯的方法数(为了方便讨论,数组下标从 1 开始),dp[i] 表示走到第 i 个楼梯的方法数目。第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达,走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。状态转移方程为:

​ dp[i]=dp[i-1]+dp[i-2]

public static int climbStair(int n){
​ if(n <= 2){
​ return n;
​ }
​ int stair1 = 1, stair2 = 2;//stair1为dp[i-2]
​ int cur = 0;
​ for(int i = 3; i <= n; i++){
​ cur = stair1 + stair2;
​ stair1 = stair2;
​ stair2 = cur;
​ }
​ return cur;
​ }

强盗抢劫问题

问题描述:抢劫一排住户,但是不能抢邻近的住户,求最大抢劫量。

如果输入为空,返回0;如果输入个数为1,返回这个数;如果说如个数为2,返回最大值。输入个数大于等于3,就需要运用动态规划。状态转移方程为:

​ dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])

public static int solution(int[] nums){
​ if(nums.length <= 0){
​ return 0;
​ }
​ if(nums.length == 1){
​ return nums[0];
​ }
​ if(nums.length == 2){
​ return nums[0] >= nums[1] ? nums[0] : nums[1];
​ }
​ int pre1 = 0,pre2 = 0;//pre1为dp[i-1]
​ int max = 0;
​ for(int i = 0; i < nums.length; i++){
​ max = Math.max(nums[i] + pre2, pre1);
​ pre2 = pre1;
​ pre1 = max;
​ }
​ return max;
​ }

Hexo常用命令

发表于 2018-08-15 | 分类于 Hexo使用 |

新建博客:hexo new “博客名”

新建页面:hexo new page “pageName” —如新建标签页:hexo new page “tags”

开启预览访问窗口:hexo server

部署到GitHub上:hexo d

清除缓存:hexo clean

生成静态网页:hexo g

快速部署:hexo g -d

笑了@

笑了@

苦逼程序员

5 日志
4 分类
4 标签
GitHub
© 2019 笑了@
由 Hexo 强力驱动
|
主题 — NexT.Pisces v5.1.4