2021级新生个人训练赛第38场

最新推荐文章于 2022-02-15 11:38:58 发布

Myajlk

最新推荐文章于 2022-02-15 11:38:58 发布

阅读量1.1k

点赞数 5

分类专栏： UPC专栏文章标签： c++ 算法图论

本文链接：https://blog.csdn.net/qq_52273733/article/details/122838549

版权

UPC专栏专栏收录该内容

20 篇文章 16 订阅

订阅专栏

问题 A: chicken

题目描述
小 x 非常喜欢小鸡翅。他得知 NSC 超市为了吸引顾客，举行了如下的活动：
一旦有顾客在其他超市找到更便宜的小鸡翅，NSC 超市将免费送给顾客 1000g 小鸡翅。小 x 为了尽可能的省钱，走遍了各大超市，统计了小鸡翅的价格。NSC 的工作人员通过不法手段盗取了这些资料。现在 NSC 的工作人员希望你能帮他们定一个尽可能低的价格（1000克小鸡翅的价格），使小 x 吃不到免费的小鸡翅。
输入
第一行两个正整数 XNSC (1 ≤ XNSC ≤ 100) 和 YNSC (1 ≤ YNSC ≤1000)，表示现在在 NSC 超市，YNSC 克小鸡翅要卖 XNSC 元。
第二行一个正整数 N，表示其他超市的个数。
接下来 N 行，每行两个正整数 Xi(1 ≤ Xi ≤ 100) 和 Yi(1 ≤ Yi ≤ 1000),表示在第 i 家超市，Yi 克小鸡翅卖 Xi 元。
输出
有且仅有一行，包含一个实数 A，表示 NSC 超市可以定的最高价格：A 元/千克。A 保留两位小数。
样例输入 Copy
5 100
3
4 100
3 100
7 100
样例输出 Copy
30.00

签到题

#include<iostream>
#include<algorithm>
#include<iomanip>
using namespace std;
double x[100001],y[100001],s[100001];
int main()
{
    cin>>x[0]>>y[0];
    s[0]=(x[0]*(1000*1.0/y[0]));
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>x[i]>>y[i];
        s[i]=(x[i]*(1000*1.0/y[i]));
    }
    sort(s,s+n+1);
    cout<<fixed<<setprecision(2)<<s[0];
     
}

问题 B: match

题目描述
小 x 在解说 F7 决赛时的搭档是韩乔生，以至于小 x 没有任何能说上话的机会。无聊的他玩起了填字游戏。一个 3*3 的九宫格里，每个格子里都被填上了一个字母，从而我们得到了 6 个单词。现在，小 x 随手写了 6 个单词，他想让你帮他找到一种填字母的方案，使得这 6 个单词都出现在了九宫格里。
输入
共六行，每行一个长度为 3 的单词（全部大写）。
输出
如果找不到方案，输出“0”（不包含引号）
如果能找到，输出包含 3 行，第 i 行对应九宫格的第 i 行（最后一行行末要换行）。
如果有多种方案，请输出每种方案对应的字符串中字典序最前的一种（将行与行首尾相连，就可以得到一个字符串）。
样例输入 Copy
ANA
ANA
DAR
DAR
RAD
RAD
样例输出 Copy
DAR
ANA
RAD

思路：枚举每一种方案，并判断是否存在，如果存在就放到set中，然后输出第一个字符串就是我们的答案（输出的时候按照三行输出就行

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=100000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,d,ans,maxn;
int f[1005][1005];
int a[N],b[N];
 
string s[10];
int st[6]={0,1,2,3,4,5};
set<string>q;
void solve(){
        for(int i = 0 ; i < 6 ; i ++ ) cin >> s[i];
        do{
            string res = "";
            res += s[st[0]];res+=s[st[1]];res+=s[st[2]];
            if(res[0] != s[st[3]][0] || res[3] != s[st[3]][1] || res[6] != s[st[3]][2]) continue;
            if(res[1] != s[st[4]][0] || res[4] != s[st[4]][1] || res[7] != s[st[4]][2]) continue;
            if(res[2] != s[st[5]][0] || res[5] != s[st[5]][1] || res[8] != s[st[5]][2]) continue;
            q.insert(res);
        }while(next_permutation(st,st+6));
        if(q.size() == 0) cout<<"0\n";
         else {string x;
              for(auto i : q){x = i ; break;}
               for(int i = 0 ; i < 9 ; i ++ ){
                     cout<<x[i];
                     if((i+1)%3 == 0) cout<<"\n";
                }
         }
}
/*
 
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}

问题 C: 【动态规划】cirs

题目描述
Czyzoiers 都想知道小 x 为什么对鸡蛋饼情有独钟。经过一番逼问，小 x 道出了实情：因为他喜欢圆。最近小 x 又发现了一个关于圆的有趣的问题：在圆上有2N 个不同的点，小 x 想用 N 条线段把这些点连接起来（每个点只能连一条线段），使所有的线段都不想交，他想知道这样的连接方案有多少种？
输入
有且仅有一个正整数 N（N≤3000）。
输出
要求的方案数（结果 mod 100000007）。
样例输入 Copy
2
样例输出 Copy
2

假如我们在圆上画了2n个点，顺时针编号为1,2,3,4……，你便会发现，如果一个奇数点和另一个奇数点相连，一定会造成将剩下所没有连线的点分在两边的都是奇数个，而后两边必定有一个点没线连或穿越其中的一条线，那么就不可能完成了。那么我们可以把奇数点看成左括号，偶数点看成右括号，然后把圆切开，就变成了一个括号匹配的方案数问题。为什么圆可以切开呢？因为A连B和B连A是同一种切法。

在这里可以用h(n)=C(2n,n)/(n+1),用扩展欧几里德求逆元。
根据费马小定理我们知道这样的结论在这里插入图片描述
固，我们可以结合卡特兰数+逆元完成本题答案 ~~这题很难啊为啥这么多人对了~~

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=100000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,d,s,ans,maxn;
int f[1005][1005];
int a[N],b[N];
 
int qsm(int a,int b){
     int res = 1;
     while(b){
          if(b&1) res = res * a % mod;
          a = a * a % mod;
          b >>= 1;
     }
     return res % mod;
}
void solve(){
           cin >> n;
           a[0] = a[1] = 1;
            for(int i=2;i<=n<<1;i++)a[i]=(a[i-1]*i)%mod;
            cout<<(((a[n<<1]%mod)*qsm(a[n+1],mod-2))%mod*qsm(a[n],mod-2))%mod;
         
}
 
/*
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}

问题 D: wtaxi

题目描述
话说小 x 有一次去参加比赛，虽然学校离比赛地点不太远，但小 x 还是想坐出租车去。大学城的出租车总是比较另类，有“拼车”一说，也就是说，你一个人坐车去，还是一堆人一起，总共需要支付的钱是一样的（每辆出租上除司机外最多坐下 4 个人）。刚好那天同校的一群 Oier 在校门口扎堆了，大家果断决定拼车去赛场。
问题来了，一辆又一辆的出租车经过，但里面要么坐满了乘客，要么只剩下一两个座位，众 Oier 都觉得坐上去太亏了，小 x 也是这么想的。
假设 N 位 Oier 准备拼车，此时为 0 时刻，从校门到目的地需要支付给出租车师傅 D 元（按车次算，不管里面坐了多少 Oier），假如 S 分钟后恰能赶上比赛，那么 S 分钟后经过校门口的出租车自然可以忽略不计了。现在给出在这 S 分钟当中经过校门的所有的 K 辆出租车先后到达校门口的时间 Ti 及里面剩余的座位 Zi(1 <= Zi <= 4)，Oier 可以选择上车几个人（不能超过），当然，也可以选择上 0 个人，那就是不坐这辆车。
俗话说，时间就是金钱，这里小 x 把每个 Oier 在校门等待出租车的分钟数等同于花了相同多的钱（例如小 x 等待了 20 分钟，那相当于他额外花了 20 元钱）。
在保证所有 Oier 都能在比赛开始前到达比赛地点的情况下，聪明的你能计算出他们最少需要花多少元钱么？
输入
每组数据以四个整数 N , K , D , S 开始，具体含义参见题目描述。
接着 K 行，表示第 i 辆出租车在第 Ti 分钟到达校门，其空余的座位数为 Zi（时间按照先后顺序）。
N <= 100，K <= 100，D <= 100，S <= 100，1 <= Zi <= 4，1<= T(i) <= T(i+1) <= S
输出
对于每组测试数据，输出占一行，如果他们所有人能在比赛前到达比赛地点，
则输出一个整数，代表他们最少需要花的钱（单位：元），否则请输出“impossible”。
样例输入 Copy
2 2 10 5
1 1
2 2
样例输出 Copy
14

思路：考虑dp，设f[i][j] : 第i辆车j个人的最少花费
因为题目说到时间的消费等价于金钱，那我们转移的时候当然也要考虑多个人等待的时间拉。
转移方程为f[i][[j] = min(f[i][j],f[i-1][j-z]+d+a*z) z∈[0,b];

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1000000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,d,s,ans,maxn;
int f[1005][1005];
int a[N],b[N];
void solve(){
           cin >> n >> k >> d >> s;
           memset(f,inf,sizeof f);
           f[0][0] = 0;
           for(int i = 1 ; i <= k ; i ++ ) cin >> a[i] >> b[i];
           for(int i = 1 ; i <= k ; i ++ ){
              for(int j = 0 ; j <= n ; j  ++ ){
                      f[i][j] = f[i-1][j];
                      for(int z = 0 ; z <= b[i] ; z ++ )
                       f[i][j] = min(f[i][j],f[i-1][j-z]+d+a[i]*z);
                 }
           }  
           if(f[k][n] >= inf/2) cout<<"impossible\n";
            else cout<<f[k][n];  
             
}
 
/*
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}

问题 E: 听歌识曲

题目描述
洛洛有一份私人歌单，歌单里面塞满了他喜欢的歌曲，像夏恋、雨道、彩月、幻昼……整整有好几百首。洛洛每天都要把他的歌单听一遍，以致于他都能知道在什么时候放的是什么歌。
洛洛在向你推荐了他的歌单之后，决定考考你，从他的歌单开始播放起，第 t 秒正在播放的是第几首歌。

输入
第一行输入两个整数 n 和 t，分别表示歌单的歌曲总数以及第 t 秒播放哪首歌。
第二行有 n 个整数，A1， A2，…， An，分别表示歌单的第 i 首歌将会播放多长时间。

输出
输出一个整数，表示歌单按顺序播放后，第t秒播放的是第几首歌。
样例输入 Copy
样例输入1
3 5
5 5 5

样例输入2
3 5
1 4 5

样例输入3
3 5
1 3 5
样例输出 Copy
样例输出1
1

样例输出2
2

样例输出3
3
【样例3解释】
歌单中总共有三首歌：
第一首歌播放1秒，占第1秒；
第二首歌播放3秒，占第2-4秒；
第三首歌播放5秒，占第5-9秒。
所以第5秒播放的是第三首歌曲。

对于30%的数据，保证1≤n≤3；
对于60%的数据，保证1≤n≤2000，1≤Ai≤500；
对于100%的数据，保证1≤n≤100000，1≤Ai≤1000，1≤t≤ 在这里插入图片描述
。

签到题

#include<iostream>
using namespace std;
int a[100001];
int main()
{
    long long n,t;
    cin>>n>>t;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        if(t-a[i]<=0)
    {
        cout<<i;
        break;
    }
    else
    {
        t-=a[i];
    }
    }
     
     
}

问题 F: 多面骰子

题目描述
洛洛现在手上有三颗多面骰子，多面骰子不是常见的六面骰子，而是33面骰子、100面骰子……一般来说，i面骰子每个面上的点数分别是1，2，3，……i。
洛洛手上的三颗骰子的面数可能并不相同，他想知道掷出三颗骰子的所有情况中，三颗骰子的点数之和出现最多次数是几点。
如果存在多个点数之和出现次数相同的情况，则按点数之和从小到大顺序输出。

输入
第一行输入三个整数 n1， n2， n3，分别表示三颗骰子各自的面数。
输出
输出一行含任意个整数，分别表示次数最多的点数之和，用空格隔开。
样例输入 Copy
样例输入1
1 2 3

样例输入2
2 3 4
样例输出 Copy
样例输出1
4 5

样例输出2
6
提示
【样例解释】
样例1，骰子投出来有以下六种情况：
1+1+1=3 1+1+2=4 1+1+3=5
1+2+1=4 1+2+2=5 1+2+3=6
可以看出4和5的出现次数最多且都是2次。

对于50%的数据，保证1 ≤ n1，n2，n3 ≤ 5；
对于80%的数据，保证1 ≤ n1，n2，n3 ≤ 10。
对于100%的数据，保证1 ≤ n1，n2，n3 ≤ 100。

思路：因为范围再100以内所以可以n^3暴力直接做

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1000000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,ans,maxn;
map<int,int>mp;
void solve(){
         int n1,n2,n3;
         cin >> n1 >> n2 >> n3;
         for(int i = 1 ; i <= n1 ; i ++ )
          for(int j = 1 ; j <= n2 ; j ++ )
           for(int k = 1 ; k <= n3 ; k ++ ){
              mp[i+j+k]++;
              if(mp[i+j+k] > maxn){
                       maxn = mp[i+j+k];
                       ans = i + j + k;
                 }
           }
           for(auto i : mp) if(i.second == maxn) cout<<i.first<<" ";
               
             
}
 
/*
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}

问题 G: 花坛

题目描述
洛洛在散步的时候，看到公园的正方形花坛里开放着许多他不认识的花卉。仔细观察之后，他又发现这些花的种植位置是有规律的。
洛洛发现在正方形花坛的最外层，即第一层上的花都是同一颜色；而花坛的第二层，花的颜色又都是一样的……正方形花坛由若干层花构成，同一层上的花都是同一颜色的，不同层之间的花颜色不一定相同。如下图所示，是一个具有三层花的正方形花坛：
在这里插入图片描述

在回到家后，洛洛还记得花坛有几层花围成，以及每层花的颜色，花的颜色用英文大小写字母来表示。但是洛洛忘记了整个花坛的图像，洛洛希望你根据他的描述，把整个花坛的图像用计算机打印字符的方式表示出来。

输入
第一行输入一个整数 n，表示正方形花坛有n层花。
第二行输入n个字符，第i个字符表示第i层花的颜色。第一层是花坛最外层。第n层是花坛最内层，只有一朵花。

输出
输出2n-1行，由(2n-1)(2n-1)个字符组成的花坛的图像。
样例输入 Copy
样例输入1
3
abC

样例输入2
4
abac
样例输出 Copy
样例输出1
aaaaa
abbba
abCba
abbba
aaaaa

样例输出2
aaaaaaa
abbbbba
abaaaba
abacaba
abaaaba
abbbbba
aaaaaaa
提示
样例解释】
样例1，即如上图，只有三层花：
第一层是颜色为字符a的花，在最外层；
第二层是颜色为字符b的花，在第二层。
第三层是颜色为字符c的花，只有一朵，在最内层。

对于20%的数据，保证只有一种花，颜色为字符a；
对于50%的数据，保证1 ≤ n ≤ 10，颜色只用小写字母表示，
对于80%的数据，保证1 ≤ n ≤ 100。
对于100%的数据，保证1 ≤ n ≤ 1000，颜色用小写字母、大写字母表示。
注意：对于不同层的花朵来说，可能存在颜色相同的情况。

思路：很简单的一道模拟题，发现每个字母就正好赋值一圈，可以很容易得出一个结论就是如果有n个字母，那输出的就是一个2n-1行和2n-1列的矩阵。

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1000000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,ans,maxn;
string s;
char a[2005][2005];
void solve(){
          cin >> n >> s;
          k = 2 * n - 1;
          for(int j = 0 ; j < n ; j ++ ){
             for(int i = j ; i < k ; i ++ ) a[j][i] = a[i][k-1] = a[k-1][i] = a[i][j] = s[j];
             k--;
          }
          for(int i = 0 ; i < 2 * n - 1 ; i ++){
             for(int j = 0 ; j < 2 * n - 1 ; j ++ )
              cout<<a[i][j];
            cout<<"\n";
          }
               
               
             
}
 
/*
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}

问题 H: 排队

题目描述
洛洛在外出旅游的时候发现社会上文明的现象越来越多，人们在买票的时候都会自发地排队等候。
遗憾的是排队的人身高参差不齐，有时候前后两人之间的身高相差太大，缺乏一些美感。
如果把前后两人的身高差(差值为正数)表示为两者前后相邻时产生的违和度，一段连续的人群因为前后两人身高不同而产生的违和度之和就可以被称为违和值。洛洛希望知道在队伍哪一段，且该段队伍由连续的m个人组成，其违和值最小。

输入
第一行输入两个正整数 n，m，n表示队伍的总人数，m表示某一段的人数。
第二行输入n个整数，表示队伍中n个人的身高(单位：厘米)。

输出
输出包含一个整数，即最小的违和值。
样例输入 Copy
样例输入1
4 3
1 2 4 7

样例输入2
4 3
10 7 5 4
样例输出 Copy
样例输出1
3

样例输出2
3
提示
样例2说明：m=3，要选取3个连续的人有两种选法：
10 7 5：违和度之和=3+2=5
7 5 4：违和度之和=2+1=3
所以答案是3。

对于50%的数据保证2 ≤ n ≤ 10；
对于80%的数据保证2 ≤ n ≤ 1000；
对于100%的数据保证2 ≤ n ≤ 100000，1 ≤ m < n，每个人的身高不超过300厘米。

思路：考虑差分

#include<iostream>
#include<algorithm>
using namespace std;
int a[1000001],b[1000001],s[1000001];
int main()
{
    int n,m,mi=999999999;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    };
    b[1]=a[1];
    for(int i=2;i<=n;i++)
    {
        b[i]=abs(a[i]-a[i-1]);
    }
    s[1]=0;
for(int i=2;i<=n;i++)
{
    s[i]=b[i]+s[i-1];
}
for(int i=m;i<=n;i++)
{
    mi=min(mi,s[i]-s[i-m+1]);
}
cout<<mi;
     
     
}

问题 I: 最大回文数

题目描述
回文数指的是一个数字，从左到右读和从右到左读都一样。例如，1221和1234321是回文数，1234不是回文数。现有n个正整数ai（i=0,1,2,3,…n-1），请找出其中最大的回文数。
输入
第一行只有一个正整数n，代表正整数ai的个数。
接下来的n行，每行包含一个正整数ai。输入保证一定有回文数。
输出
一行，一个正整数，即最大的回文数。
样例输入 Copy
【样例1】
3
4718
1221
121
【样例2】
5
3944
953
8
75739
46
样例输出 Copy
【样例1】
1221
【样例2】
8
提示
对于30%的数据，1≤n≤100，1≤ai≤108。
对于60%的数据，1≤n≤1000，1≤ai≤1016。
对于100%的数据，1≤n≤104，1≤ai≤1032。

思路：暴力判断就行，复杂度O(n)

#include<iostream>
#include<algorithm>
using namespace std;
string e[100001];
bool cmp(string a,string b)
{
    if(a.size() ==b.size() )
    return a<b;
    else
    return a.size() <b.size() ;
}
int main()
{
long long n,mm=-1;
cin>>n;
int k=0;
while(n--)
{   
    string a,b;
    cin>>a;
    b=a;
    reverse(b.begin() ,b.end() );
    if(a==b)
    {
        e[k++]=a;
    }
}
sort(e,e+k,cmp);
cout<<e[k -1];
}

问题 J: 金币

题目描述
乔治在梦中来到了一个神奇部落，这个部落的神树具有奇特的功能：对于每一位新朋友，都会获赠金币，而且金币的数量会随时间的延续而增加：
第1周，每天1枚金币；
第2周，每天2枚金币；
第3周，每天3枚金币；……
请问：至少多少天，乔治的金币数量达到n枚？
输入
一行，只有一个正整数n。
输出
一行，一个整数，表示金币达到n枚所需的最少天数。
样例输入 Copy
30
样例输出 Copy
17
提示
第1周：每天1枚，共7枚；
第2周：每天2枚，共14枚；
第3周：每天3枚，3天即可：7+14+3*3=30。
共计：7+7+3=17天。
【数据规模】
对于30%的数据，n不超过2147483647；
对于100%的数据，n的位数不超过18。

思路：二分在第几周，然后在精确判断是第X天，复杂度是O(logn)
注意二分时取右边界不要太大，自己粗略估计一下就行，取太大爆long long的。
~~别问我二分是啥或者代码里面二分什么意思，看得懂的自然看得懂，看不懂我讲了你也听不懂，看不懂建议立刻去学，很简单的~~

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<bits/stdc++.h>
# include<unordered_map>
 
 
# define eps 1e-9
# define fi first
# define se second
# define ll long long
# define int ll
// cout<<fixed<<setprecision(n) 
//bool operator<(const Node& x )
using namespace std;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=100000007;
const int N=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
double e = exp(1);
 
int T,n,m,k,d,s,ans,maxn;
int f[1005][1005];
int a[N],b[N];
 
bool check(int x){
     int sum = 7 * x * (x+1);
     return sum >= 2*n;
      
}
void solve(){
           cin >> n;
           int l = 0 , r = 2e9+10;
           while(l < r){
              int mid = l + r >> 1;
              if(check(mid)) r = mid;
               else l = mid + 1;
           }
           //cout<<l<<endl;
           ans = (l-1) * 7;
           m = (l-1)*(7+7*(l-1))/2;
           //cout<<m<<endl; 
           while(m < n){
               ans++;
               m+=l;
           }
           cout<<ans;
}
/*
 
*/
signed main(){  
    std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); 
  // cin >> T;
       T = 1;
    while(T--){
        solve();
    } 
    return 0; 
}