C++博客-Uriel's Corner-文章分类-数学

[LeetCode]1611. Minimum One Bit Operations to Make Integers Zero (Hard) Python-2023.11.30

Uriel — Thu, 30 Nov 2023 17:41:00 GMT

给出一个十进制数，问其二进制表示通过以下两种操作几次可以变成0

1. Change the rightmost (0th) bit in the binary representation of n.

2. Change the ith bit in the binary representation of n if the (i-1)th bit is set to 1 and the (i-2)th through 0th bits are set to 0.

很妙的思路参考 -> https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/solutions/2273798/easy-to-understand-6-line-solution-with-explanation-o-n-time-o-1-space/?envType=daily-question&envId=2023-11-30

1 #1611
2 #Runtime: 17 ms (Beats 66.67%)
3 #Memory: 13.4 MB (Beats 33.33%)
4
5 class Solution(object):
6     def minimumOneBitOperations(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         binary = format(n, "b")
12         ans = 0
13         for i in xrange(1, len(binary) + 1):
14             if binary[-i] == "1":
15                 ans = 2**i - 1 - ans
16         return ans

Uriel 2023-12-01 01:41 发表评论

[LeetCode]1814. Count Nice Pairs in an Array (Medium) Python-2023.11.21

Uriel — Tue, 21 Nov 2023 13:48:00 GMT

给出一个数组，问其中有多少个a，b数对，符合a+rev(b)=b+rev(a)，rev为数字反转
a+rev(b)=b+rev(a) -> a - rev(a) + b - rev(b) = 0，所以预处理所有a-rev(a)，然后用Counter计算每种value出现次数然后累加

#1814
#Runtime: 586 ms (Beats 78.13%)
#Memory: 23 MB (Beats 43.75%)

class Solution(object):
    def countNicePairs(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums = [x - int(str(x)[::-1]) for x in nums]
        ans = 0
        for x in Counter(nums).values():
            ans = (ans + (x - 1) * x // 2) % (10**9 + 7)
        return ans

Uriel 2023-11-21 21:48 发表评论

[LeetCode]343. Integer Break (Medium) Python-2023.10.06

Uriel — Fri, 06 Oct 2023 17:19:00 GMT

将一个数拆成几个数之和，使几个数乘积最大
尽可能拆成最多的3，若剩下4则不拆

1 #343
2 #Runtime: 17 ms (Beats 54.55%)
3 #Memory: 13.3 MB (Beats 42.93%)
4
5 class Solution(object):
6     def integerBreak(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         if n < 4:
12             return n - 1
13         if n % 3 == 0:
14             return 3**(n//3)
15         if n % 3 == 1:
16             return 3**(n//3 - 1) * 4
17         return 3**(n//3) * 2

Uriel 2023-10-07 01:19 发表评论

[LeetCode]880. Decoded String at Index (Medium) Python-2023.09.27

Uriel — Wed, 27 Sep 2023 09:41:00 GMT

给出一列字符串，里面由字符和数字2-9组成，遇到字符就加入stack，遇到数字（设为d），就把到目前为止的字符stack重复d-1次，问最后的结果字符串第k为是什么字符
如果把整个结果字符串都记录下来会MLE，所以只要倒推第k位对应第一次出现时的位置，输出那个字符

1 #880
2 #Runtime: 20 ms Beats 12.50%)
3 #Memory: 13.5 MB (Beats 29.17%)
4
5 class Solution(object):
6     def decodeAtIndex(self, s, k):
7         """
8         :type s: str
9         :type k: int
10         :rtype: str
11         """
12         l = 0
13         for ch in s:
14             if ch.isdigit():
15                 l *= int(ch)
16             else:
17                 l += 1
18         for i in range(len(s) - 1, -1, -1):
19             if s[i].isdigit():
20                 l //= int(s[i])
21                 k %= l
22             else:
23                 if l == k or k == 0:
24                     return s[i]
25                 l -= 1

Uriel 2023-09-27 17:41 发表评论

[LeetCode]799. Champagne Tower (Medium) Python-2023.09.24

Uriel — Sun, 24 Sep 2023 08:53:00 GMT

有query_row层垒起来的玻璃杯，第i层有i个杯子，从第一层开始倒水，倒进去poured杯水，求问第query_row层第query_glass个杯子有多少水
按层往下算，每次减去当前杯子装进的1杯，剩下对半分入下一层相邻两个杯子

1 #799
2 #Runtime: 59 ms (Beats 62.50%)
3 #Memory: 13.3 MB (Beats 45.11%)
4
5 class Solution(object):
6     def champagneTower(self, poured, query_row, query_glass):
7         """
8         :type poured: int
9         :type query_row: int
10         :type query_glass: int
11         :rtype: float
12         """
13         dp = [[0 for _ in range(x)] for x in range(1, query_row + 2)]
14         dp[0][0] = poured
15         for i in range(query_row):
16             for j in range(len(dp[i])):
17                 tp = (dp[i][j] - 1) / 2.0
18                 if tp > 0:
19                     dp[i + 1][j] += tp
20                     dp[i + 1][j + 1] += tp
21         return dp[query_row][query_glass] if dp[query_row][query_glass] <= 1 else 1

Uriel 2023-09-24 16:53 发表评论

[LeetCode]1359. Count All Valid Pickup and Delivery Options (Hard) Python-2023.09.10

Uriel — Sun, 10 Sep 2023 07:42:00 GMT

一共有n个order，每个order先进行pickup操作，再进行delivery操作，问完成n个order一共几种序列
思路参考-> https://leetcode.com/problems/count-all-valid-pickup-and-delivery-options/solutions/516968/java-c-python-easy-and-concise/

1 #1359
2 #Runtime: 13 ms (Beats 77.42%)
3 #Memory: 13.2 MB (Beats 80.65%)
4
5 class Solution(object):
6     def countOrders(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         MOD = 10 ** 9 + 7
12         ans = 1
13         for i in range(2, n + 1):
14             ans = ans * (2 * i - 1) * i % MOD
15         return ans

Uriel 2023-09-10 15:42 发表评论

[LeetCode]808. Soup Servings (Medium) Python3-2023.07.29

Uriel — Sat, 29 Jul 2023 10:07:00 GMT

初始A，B两种汤都有n ml，每次可以执行如下四种操作之一，输出A先喝完的概率*1+AB同时喝完的概率*0.5，精度10^-5，递归+DP，但直接做会超过迭代深度，参考Discussion发现由输出精度可以推算n大于某个值的时候可以直接输出1

1 #808
2 #Runtime: 36 ms (Beats 100%)
3 #Memory: 17 MB (Beats 79.25%)
4
5 class Solution:
6     def soupServings(self, n: int) -> float:
7         if n >= 4276:
8             return 1.0
9         @lru_cache(None)
10         def dp(x, y):
11             if x <= 0 and y > 0:
12                 return 1
13             if x <= 0 and y <= 0:
14                 return 0.5
15             if x > 0 and y <= 0:
16                 return 0
17             return (dp(x - 100, y) + dp(x - 75, y - 25) + dp(x - 50, y - 50) + dp(x - 25, y - 75)) * 0.25
18
19         return dp(1.0 * n, 1.0 * n)

Uriel 2023-07-29 18:07 发表评论

[LeetCode]319. Bulb Switcher (Medium) Python-2023.04.27

Uriel — Thu, 27 Apr 2023 13:49:00 GMT

有n个灯泡，开始全部点亮，然后一次关闭/电量2的倍数、3的倍数...n的倍数，问最后剩下几个灯
看了Discussion才明白->https://leetcode.com/problems/bulb-switcher/solutions/3459201

1 #319
2 #Runtime: 17 ms (Beats 49.15%)
3 #Memory: 13.2 MB (Beats 91.53%)
4
5 class Solution(object):
6     def bulbSwitch(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         return int(sqrt(n))

Uriel 2023-04-27 21:49 发表评论

[LeetCode]2348. Number of Zero-Filled Subarrays (Medium) Python-2023.03.21

Uriel — Tue, 21 Mar 2023 08:08:00 GMT

给出一个数字list，问其中全0子串有多少
不晓得为啥这样的简单数学题是Medium？假设有连续的k个0，那么可以生成1+2+...+k个全0子串，简单等差数列求和

1 #2348
2 #Runtime: 865 ms (Beats 80.65%)
3 #Memory: 22.8 MB (Beats 61.29%)
4
5 class Solution(object):
6     def zeroFilledSubarray(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         ans, t = 0, 0
12         for i in range(len(nums)):
13             if nums[i] != 0:
14                 t = 0
15             else:
16                 t += 1
17                 ans += t
18         return ans

Uriel 2023-03-21 16:08 发表评论

[LeetCode]382. Linked List Random Node (Medium) Python-2023.03.10

Uriel — Fri, 10 Mar 2023 09:44:00 GMT

构造一个针对单 1 #382

2 #Runtime: 167 ms (Beats 33.87%)
3 #Memory: 17.9 MB (Beats 11.29%)
4
5 # Definition for singly-linked list.
6 # class ListNode(object):
7 #     def __init__(self, val=0, next=None):
8 #         self.val = val
9 #         self.next = next
10 class Solution(object):
11
12     def __init__(self, head):
13         """
14         :type head: Optional[ListNode]
15         """
16         self.head = head
17
18
19     def getRandom(self):
20         """
21         :rtype: int
22         """
23         ans = self.head
24         p = self.head
25         cnt = 0
26         while p:
27             cnt += 1
28             if random.randint(1, cnt) == 1:
29                 ans = p.val
30             p = p.next
31         return ans
32
33 # Your Solution object will be instantiated and called as such:
34 # obj = Solution(head)

35 # param_1 = obj.getRandom()链表的函数，使之每次调用可以随机输出其中一个值
参考了discussion的Reservoir sampling思路->https://leetcode.com/problems/linked-list-random-node/solutions/3278159/easy-solutions-in-java-python-and-c-look-at-once/

Uriel 2023-03-10 17:44 发表评论

[LeetCode]1523. Count Odd Numbers in an Interval Range (Easy) Python-2023.02.13

Uriel — Mon, 13 Feb 2023 09:31:00 GMT

问[low high]区间内有多少基数，简单数学题，O(1)

1 #1523
2 #Runtime: 22 ms (Beats 34.12%)
3 #Memory: 13.2 MB (Beats 98.78%)
4
5 class Solution(object):
6     def countOdds(self, low, high):
7         """
8         :type low: int
9         :type high: int
10         :rtype: int
11         """
12         ans = 0
13         if low < high:
14             ans = (high - low + 1) // 2
15         if low % 2 and high % 2:
16             ans += 1
17         return ans

Uriel 2023-02-13 17:31 发表评论

[LeetCode]974. Subarray Sums Divisible by K (Medium) Python-2023.01.19

Uriel — Thu, 19 Jan 2023 12:11:00 GMT

给定一串数nums和整数k，问这串数的子串和可以被k整除的子串（连续的一段）有多少
参考了Discussion：
先预处理prefix_sum（%k之后的值）
如果子串nums[i]~num[j]之和可以被k整除，说明prefix_sum[i] = prefix_sum[j]，于是用dict存各种prefix_sum的可能性有多少，最后
ans = sum(prefix_sum[x] * (prefix_sum[x]- 1) / 2), x=0~k-1
因为是C(n, 2)的组合数，所以不必等所有prefix_sum计算完再一个个算，在扫描nums，计算当前prefix_sum的时候顺便累加即可
注意初始化prefix_sum[0] = 1，因为一个数都不取的话和为0

1 #974
2 #Runtime: 232 ms (Beats 92.68%)
3 #Memory: 16.8 MB (Beats 37.80%)
4
5 class Solution(object):
6     def subarraysDivByK(self, nums, k):
7         """
8         :type nums: List[int]
9         :type k: int
10         :rtype: int
11         """
12         pre_sum = defaultdict(int)
13         t, ans = 0, 0
14         pre_sum[0] = 1
15         for i in nums:
16             t = (t + i) % k
17             pre_sum[t] += 1
18             ans += pre_sum[t] - 1
19         return ans

Uriel 2023-01-19 20:11 发表评论

[LeetCode]60. Permutation Sequence (Hard) Python-2022.11.06

Uriel — Sun, 06 Nov 2022 21:08:00 GMT

求1-n这n个数字的第k个排列数

直接不断求下一个排列数会TLE，考虑到i个数字的排列数一共i!种，于是对从做到位每一位置i，不断整除剩余数字个数的阶乘，来确定该位数应该填充哪个

1 #60
2 #Runtime: 29 ms
3 #Memory Usage: 13.7 MB
4
5 class Solution(object):
6     def getPermutation(self, n, k):
7         """
8         :type n: int
9         :type k: int
10         :rtype: str
11         """
12         nums = range(1, n + 1)
13         ans = []
14         fac = []
15         nt = 1
16         for i in range(2, n+2):
17             fac.append(nt)
18             nt *= i
19         k -= 1
20         for i in range(n):
21             nt = k // fac[n - i - 2]
22             ans.append(nums[nt])
23             nums.pop(nt)
24             k %= fac[n - i - 2]
25         return ''.join(str(i) for i in ans)

Uriel 2022-11-07 05:08 发表评论

[LeetCode]31. Next Permutation (Medium) Python-2022.11.06

Uriel — Sun, 06 Nov 2022 20:27:00 GMT

给一列数，生成下一个排列数

从最后一个数字向前扫，找到最长的升序后缀，升序后缀前一位和升序后缀第一位大于该数的数字交换，然后升序列reverse

举例：

1 2 5 3 3 0

升序后缀的前一位为2，升序后缀第一个大于2的数为3，交换两个数，得到

1 3 5 3 2 0

reverse升序后缀

1 3 0 2 3 5

如果已经是最后一个排列数，如

5 4 3 2 1

则不存在前一位，直接reverse

1 #31
2 #Runtime: 53 ms
3 #Memory Usage: 13.3 MB
4
5 class Solution(object):
6     def nextPermutation(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: None Do not return anything, modify nums in-place instead.
10         """
11         f = -1
12         for i in range(len(nums)-2, -1, -1):
13             if nums[i] < nums[i + 1]:
14                 f = i
15                 break
16         if f >= 0:
17             for i in range(len(nums)-1, -1, -1):
18                 if nums[i] > nums[f]:
19                     nums[f], nums[i] = nums[i], nums[f]
20                     break
21         nums[f + 1 : ] = nums[f + 1 : ][ : : -1]
22         return nums
23

Uriel 2022-11-07 04:27 发表评论

POJ 1017 Packets---模拟？数学？

Uriel — Wed, 10 Mar 2010 12:28:00 GMT

        还是09年暑假集训开始不久的某天晚上做的一道题了。。当时真是弱啊。。以切水为生。。只会模拟然后找规律。。
        正好有人问，就在这里贴一下，当时的代码好WS。。大家无视之。。
        方法么。。就是先放6*6，5*5，4*4，3*3然后先尽量在缝隙里塞2*2，1*1，不够的话再另外用新的装，每种情况塞几个啥的那些数字草稿纸上画画就出来了~

#include<stdio.h>
#include<math.h>
#include<stdlib.h>

int w1,w2,w3,w4,w5,w6,sum,x,s1,y,s2,temp;
int main()
{
    while(1)
    {
        scanf("%d %d %d %d %d %d",&w1,&w2,&w3,&w4,&w5,&w6);
        if(w1==0 && w2==0 && w3==0 && w4==0 && w5==0 && w6==0)exit(0);
        temp=w2;
        s2=0;
        sum=w6+w5+w4+ceil(w3/4.0);
        s2+=11*w5;
        w2-=5*w4;
        s2+=20*w4;
        if(w3%4==1)
        {
            w2-=5;
            s2+=27;
        }
        else if(w3%4==2)
        {
            w2-=3;
            s2+=18;
        }
        else if(w3%4==3)
        {
            w2-=1;
            s2+=9;
        }
        x=0;
        if(w2>=0)
        {
            sum+=ceil(w2/9.0);
            s2+=36*(ceil(w2/9.0));
            w1=w1-s2+temp*4;
            if(w1>0)sum+=ceil(w1/36.0);
        }
        else
        {
            w1=w1-s2+temp*4;
            if(w1>0)sum+=ceil(w1/36.0);
        }
        printf("%d\n",sum);
    }
    return 0;
}

Uriel 2010-03-10 20:28 发表评论

POJ 1995 Raising Modulo Numbers---数论

Uriel — Fri, 05 Feb 2010 20:05:00 GMT

直接用快速模取幂的模板过的。。还记得是09' Regional 上海赛热身赛的某题数论知道式子不用快速模取幂就一直TLE。。然后从天哥大牛那里第一次知道了这个东西。。这题是第一次在POJ上用到。。

/*Problem: 1995  User: Uriel
   Memory: 164K  Time: 94MS
   Language: C++  Result: Accepted*/

#include<stdio.h>
#include<stdlib.h>

int a,b,t,m,res,h;

int modExp(int a, int b, int n)
{
    int t = 1, y = a;
    while(b != 0)
    {
        y %= n;
        if(b % 2 == 1)
            t = t % n * y % n;
        y = y * y % n;
        b = b >> 1;
    }
    return t;
}

int main()
{
    int i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&m);
        scanf("%d",&h);
        res=0;
        for(i=0;i<h;i++)
        {
            scanf("%d %d",&a,&b);
            res=(res+modExp(a,b,m))%m;
        }
        printf("%d\n",res);
    }
//    system("PAUSE");
    return 0;
}

Uriel 2010-02-06 04:05 发表评论

POJ 2085 Inversion---找规律

Uriel — Wed, 26 Aug 2009 07:09:00 GMT

这题丢了很久，一直没什么思路，今天看Discuss说找规律然后就尝试了一下，被绕得有点头晕。。
在网上找了一个解题报告，貌似没考虑 m=0 的情况，但是也可以AC，题目的Bug？
然后理了下思路，一次AC。。考虑了比如（1 0）输出 1 的情况
下面是用来找规律的数据

1 2 3 4 5 6 7 8 9 10   9      0     remain          -
1 2 3 4 5 6 7 8 10 9   8      1   |    10, 9
1 2 3 4 5 6 7 9 10 8   7      2   |    9, 10 8
1 2 3 4 5 6 7 10 9 8   7          |    10, 9 8
1 2 3 4 5 6 8 10 9 7   6      3   | 8, 10 9 7
1 2 3 4 5 6 9 10 8 7   6           |    9, 10 8 7
1 2 3 4 5 6 10 9 8 7   6           |    10, 9 8 7
1 2 3 4 5 7 10 9 8 6   5      4   |    7, 10 9 8 6
1 2 3 4 5 8 10 9 7 6   5           |    8, 10 9 7 6
1 2 3 4 5 9 10 8 7 6   5           |    9, 10 8 7 6
1 2 3 4 5 10 9 8 7 6   5          \|/  10, 9 8 7 6
1 2 3 4 6 10 9 8 7 5   4      5
1 2 3 4 7 10 9 8 6 5   4
1 2 3 4 8 10 9 7 6 5   4
1 2 3 4 9 10 8 7 6 5   4
1 2 3 4 10 9 8 7 6 5   4
1 2 3 5 10 9 8 7 6 4   3      6
1 2 3 6 10 9 8 7 5 4   3
1 2 3 7 10 9 8 6 5 4   3
1 2 3 8 10 9 7 6 5 4   3
1 2 3 9 10 8 7 6 5 4   3
1 2 3 10 9 8 7 6 5 4   3
1 2 4 10 9 8 7 6 5 3   2      7
1 2 5 10 9 8 7 6 4 3   2
1 2 6 10 9 8 7 5 4 3   2
1 2 7 10 9 8 6 5 4 3   2
1 2 8 10 9 7 6 5 4 3   2
1 2 9 10 8 7 6 5 4 3   2
1 2 10 9 8 7 6 5 4 3   2
1 3 10 9 8 7 6 5 4 2   1     8
1 4 10 9 8 7 6 5 3 2   1
1 5 10 9 8 7 6 4 3 2   1
1 6 10 9 8 7 5 4 3 2   1
1 7 10 9 8 6 5 4 3 2   1
1 8 10 9 7 6 5 4 3 2   1
1 9 10 8 7 6 5 4 3 2   1
1 10 9 8 7 6 5 4 3 2   1
2 10 9 8 7 6 5 4 3 1   0      9
3 10 9 8 7 6 5 4 2 1   0
4 10 9 8 7 6 5 3 2 1   0
5 10 9 8 7 6 4 3 2 1   0
6 10 9 8 7 5 4 3 2 1   0
7 10 9 8 6 5 4 3 2 1   0
8 10 9 7 6 5 4 3 2 1   0
9 10 8 7 6 5 4 3 2 1   0
10 9 8 7 6 5 4 3 2 1   0

下面是AC代码：

/*Problem: 2085  User: Uriel
   Memory: 384K  Time: 125MS
   Language: C++  Result: Accepted*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int n,m,i,j,k,flag[50001];

int main()
{
    while(1)
    {
        scanf("%d %d",&n,&m);
        if(n==-1 && m==-1)break;
        i=0;
        memset(flag,0,sizeof(flag));
        while((1+(i+1)*i/2)<m)i++;
        for(j=1;j<=n-i-1;j++)
        {
            flag[j]=1;
            printf("%d ",j);
        }
        k=n-i+(m-(i-1)*i/2);
        printf("%d ",k);
        flag[k]=1;
        for(j=n;j>=1;j--)
        {
            if(!flag[j])
            {
                printf("%d ",j);
            }
        }
        printf("\n");
    }
    system("PAUSE");
    return 0;
}

Uriel 2009-08-26 15:09 发表评论