codeforce round 399# B

本文介绍了一道编程题的解决方法,题目背景基于《权力的游戏》剧情,Sam需解决一个数学问题以成为学士。任务是对一个整数进行递归分解,直至所有数字变为0或1,并统计指定范围内的1的数量。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

      B. Code For 1

time limit per test:2 seconds
memory limit per test:256 megabytes
input:standard input
output:standard output

Jon fought bravely to rescue the wildlings who were attacked by the white-walkers at Hardhome. On his arrival, Sam tells him that he wants to go to Oldtown to train at the Citadel to become a maester, so he can return and take the deceased Aemon’s place as maester of Castle Black. Jon agrees to Sam’s proposal and Sam sets off his journey to the Citadel. However becoming a trainee at the Citadel is not a cakewalk and hence the maesters at the Citadel gave Sam a problem to test his eligibility.

Initially Sam has a list with a single element n. Then he has to perform certain operations on this list. In each operation Sam must remove any element x, such that x > 1, from the list and insert at the same position , , sequentially. He must continue with these operations until all the elements in the list are either 0 or 1.

Now the masters want the total number of 1s in the range l to r (1-indexed). Sam wants to become a maester but unfortunately he cannot solve this problem. Can you help Sam to pass the eligibility test?

Input

The first line contains three integers n, l, r (0 ≤ n < 250, 0 ≤ r - l ≤ 105, r ≥ 1, l ≥ 1) – initial element and the range l to r.

It is guaranteed that r is not greater than the length of the final list.

Output

Output the total number of 1s in the range l to r in the final sequence.

Examples
Input
7 2 5

Output
4

Input
10 3 10

Output
5

Note

Consider first example:

Elements on positions from 2-nd to 5-th in list is [1, 1, 1, 1]. The number of ones is 4.

For the second example:

Elements on positions from 3-rd to 10-th in list is [1, 1, 1, 0, 1, 0, 1, 0]. The number of ones is 5.

**求:一个数分解为0和1后,区间【l,r】之间1的个数
思路:将一个数分解dfs+dp[x](表示x分解后的长度)

#include<iostream>
#include<cmath>
#include<map>
#include<string>
#include<cstdio>
using namespace std;
long long n,l,r;
map<long,long> dp;
long long dfs(long long x)      //求出 dp[x](表示x分解后的长度)
{
    if (x != 0)
        dp[x] += 2 * dfs(x / 2) + 1;     
    return dp[x];
}
int main()
{
        cin >> n >> l >> r;
        dp[1] = 1;
        dp.clear();
        long long m = n;
        dfs(m);
        long long num = 0;
        for (long long i = l;i <= r;i++)       //从l到r逐个判断是否为1

        {
            long long ans = 0, temp = n;
            while (temp)
            {
                if (ans + dp[temp / 2] + 1 == i)
                {
                    if(temp%2==1) 
                        num++;
                    break;
                }
                else
                {
                    if (ans + dp[temp / 2] > i)
                    {
                        temp /= 2;
                    }
                    else
                    {
                        if (ans + dp[temp / 2] == i)
                        {
                            num++;
                            break;
                        }
                        else
                        {
                            ans += dp[temp / 2] + 1;
                        }
                    }
                }
                if (ans == i)
                {
                    num++;
                    break;
                }


            }
        }
        cout << num << endl;
    return 0;
}
### Codeforces Problem 797B Explanation The problem titled "Restoring the Permutation" requires reconstructing a permutation from its prefix sums modulo \( m \). Given an array of integers representing these prefix sums, one must determine whether it is possible to restore such a permutation. In this context, a **permutation** refers to an ordered set containing each integer exactly once within a specified range. The task involves checking if there exists any valid sequence that matches the provided conditions when performing operations as described in the problem statement[^1]. To solve this issue effectively: - Iterate through all elements while maintaining two variables: `current_sum` which tracks cumulative sum during iteration; and `min_value`, used later for adjustments. ```cpp int n, m; cin >> n >> m; vector<int> s(n); for (auto& x : s) cin >> x; ``` Calculate differences between consecutive terms after adjusting initial values appropriately by subtracting minimum value found so far at every step. This adjustment ensures non-negativity throughout calculations without altering relative order among elements. Check feasibility based on properties derived from constraints given in the question text. Specifically, ensure no duplicate residues appear under modulus operation since they would violate uniqueness required for permutations. Finally, construct answer using adjusted difference list obtained previously along with necessary checks ensuring correctness according to rules outlined above.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值