力扣剑指Offer 第24天 数学（中等）剑指 Offer 14- I. 剪绳子 剑指 Offer 57 - II. 和为s的连续正数序列 剑指 Offer 62. 圆圈中最后剩下的数字

力扣剑指Offer 第24天 数学（中等）剑指 Offer 14- I. 剪绳子 剑指 Offer 57 - II. 和为s的连续正数序列 剑指 Offer 62. 圆圈中最后剩下的数字

剑指 Offer 14- I. 剪绳子(中等)

题目

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1]。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

提示：

2 <= n <= 58

题解

数学推导

将数拆分相乘求最大

class Solution {
    public int cuttingRope(int n) {
		if(n<=3)return n-1;//3->2|1=2 2->1|1=1
        int divide=n/3;
        int mod=n%3;
        int ans=1;
        if(mod==1){
            divide--;
            ans<<=2;
        }else if(mod==2){
            ans<<=1;
        }
		return ans*(int)Math.pow(3,divide);
    }
}

剑指 Offer 57 - II. 和为s的连续正数序列

题目

输入一个正整数 target，输出所有和为 target的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]

示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

限制：

1 <= target <= 10^5

题解

双指针

从中间开始双指针向左滑动 把符合条件的组合复制到链表中（addFirst 最后 toArray 时将获得正确的顺序）

class Solution {
    public int[][] findContinuousSequence(int target) {
        //暴力双指针滑窗 从中间向左滑动
        int l=target>>1,r=l+1,sum;
        int[] tarArr=new int[target+1];
        for(int i=1;i<=target;i++)tarArr[i]=i;
        LinkedList<int[]> arr=new LinkedList<>();
        while(l>0){
            sum=(l+r)*(r-l+1)>>1;
            if(sum==target)arr.addFirst(Arrays.copyOfRange(tarArr,l--,1+r--));
            else if(sum<target)l--;
            else {
                r--;
                l--;
            }
        }   
        int[][] ans=new int[arr.size()][];   
        return arr.toArray(ans);      
    }
}

剑指 Offer 62. 圆圈中最后剩下的数字

题目

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

示例 1：

输入: n = 5, m = 3
输出: 3

示例 2：

输入: n = 10, m = 17
输出: 2

限制：

1 <= n <= 10^5

1 <= m <= 10^6

题解

动态规划

1. 设置[n,m]问题的解为f(n)

2. [n,m]首轮删除的节点为 (m-1)%n(用取模运算模拟环)得到[n-1,m]问题

3. 下一轮将从t = m%n开始(删除的为t-1)

[n-1,m]问题	[n,m]问题
0	t
1	t+1
…	…
n-1	t-2

4. 因此可以推导：
   f(n)=(f(n-1)+t)%n=(f(n-1)+m%n)%n=(f(n-1)+m)%n

5. 将递归转换为递推 f(1)=0

   m=3
   f(1)	0
   f(2)	(0+3)%2 = 1
   f(3)	(1+3)%3 = 1
   …
   f(n)	(f(n-1)+m)%n

class Solution {
    public int lastRemaining(int n, int m) {
        int ans=0;
        for(int i=2;i<=n;i++)ans=(ans+m)%i;
        return ans;
    }
}

数组模拟(1367ms)

class Solution {
    public int lastRemaining(int n, int m) {
        ArrayList<Integer> l=new ArrayList<>(n);
        for(int i=0;i<n;i++)l.add(i);
        int p=0;
        while(l.size()!=1)l.remove(p=(p+m-1)%l.size());
        return l.get(0);
    }
}

循环链表模拟(超时)

class Solution {
    static class ListNode{
        int value;
        ListNode next;
        ListNode(int v){value=v;}
        void delete(){
            value=next.value;
            next=next.next;
        }
        static ListNode buildCircle(int n,int m){
            ListNode head=new ListNode(0),last=head,cur=null;
            for(int i=1;i<n;i++){
                cur=new ListNode(i);
                last.next=cur;
                last=cur;
            }
            cur.next=head;
            return head;
        }
    }
    public int lastRemaining(int n, int m) {
        if(n==1)return 0;
        ListNode head=ListNode.buildCircle(n,m),cur=head;
        int cnt=0;
        while(cur.next!=cur){
            if(++cnt==m){
                cnt=0;
                cur.delete();
            }else{
                cur=cur.next;
            }
        }
        return cur.value;
    }
}