text
stringlengths 49
983k
|
|---|
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
void print_text(const string& text){
int offset = 0;
int text_i = 0;
while(offset < text.size()){
for(text_i = offset; text_i < text.size(); text_i++){
if(text_i - offset >= 72) break;
printf("%c",text[text_i]);
}
printf("\n");
offset += 72;
}
}
void print_co_occurrence(const string& text,const string& query){
int head = 0;
int tail = 0;
int include_keys = 0;
int freq[256] = {};
bool is_key[256];
memset(is_key,false,sizeof(is_key));
for(int query_i = 0; query_i < query.size(); query_i++){
is_key[query[query_i]] = true;
}
int min_tail = INF;
int min_len = INF;
int ans_freq = 0;
string ans = "";
while(tail < text.size()){
for(;head < text.size();head++){
if(is_key[text[head]] && !freq[text[head]]++){
include_keys++;
if(include_keys == query.size()){
head++;
break;
}
}
}
for(;tail <= head;tail++){
if(is_key[text[tail]] && !--freq[text[tail]]){
if(include_keys == query.size()) {
if((head -1) - tail + 1 < min_len){
min_len = (head -1) - tail + 1;
ans = text.substr(tail,(head -1) - tail + 1);
ans_freq = 1;
}
else if((head -1) - tail + 1 == min_len){
ans_freq++;
}
}
include_keys--;
tail++;
break;
}
}
}
if(ans_freq == 0){
printf("%d\n",ans_freq);
printf("\n");
}
else{
printf("%d\n",ans_freq);
printf("\n");
print_text(ans);
printf("\n");
}
}
int main(){
string str;
int phase = 0;
string text = "";
string query = "";
while(getline(cin,str)){
if(str.size() == 0){
phase++;
continue;
}
if(phase % 2 == 0){
text += str;
}
else{
query = str;
print_co_occurrence(text,query);
query = "";
text = "";
}
}
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
string buf,line,pattern;
vector<int> LOC[128];
bool check(int start,int end){
bool FLG;
int left,right,m,tmp_start,tmp_end;
for(int i = 0; i < pattern.length(); i++){
int ch = pattern[i];
left = 0,right = LOC[ch].size()-1,m = (left+right)/2;
tmp_start = BIG_NUM;
while(left <= right){
if(LOC[ch][m] >= start){
tmp_start = m;
right = m-1;
}else{
left = m+1;
}
m = (left+right)/2;
}
if(tmp_start == BIG_NUM)return false;
left = tmp_start,right = LOC[ch].size()-1,m = (left+right)/2;
tmp_end = BIG_NUM;
while(left <= right){
if(LOC[ch][m] <= end){
tmp_end = m;
left = m+1;
}else{
right = m-1;
}
m = (left+right)/2;
}
if(tmp_end == BIG_NUM)return false;
}
return true;
}
void func(){
for(int i = 0; i < 128; i++)LOC[i].clear();
line += buf;
while(true){
getline(cin,buf);
if(buf == "")break;
line += buf;
}
getline(cin,pattern);
getline(cin,buf);
for(int i = 0; i < line.length(); i++){
LOC[line[i]].push_back(i);
}
for(int i = 0; i < pattern.length(); i++){
if(LOC[pattern[i]].size() == 0){
printf("0\n\n");
return;
}
}
bool FLG;
int left,right,m,minimum = BIG_NUM,ans_count = 1,tmp_end;
int ans_start,ans_end;
for(int start = 0; start < line.length(); start++){
left = start,right = line.length()-1,m = (left+right)/2;
tmp_end = BIG_NUM;
while(left <= right){
if(check(start,m)){
tmp_end = m;
right = m-1;
}else{
left = m+1;
}
m = (left+right)/2;
}
if(tmp_end == BIG_NUM)continue;
if(tmp_end-start+1 < minimum){
minimum = tmp_end-start+1;
ans_count = 1;
ans_start = start;
ans_end = tmp_end;
}else if(tmp_end-start+1 == minimum){
ans_count++;
}
}
printf("%d\n\n",ans_count);
for(int i = ans_start; i <= ans_end; i += 72){
for(int k = i; k <= min(ans_end,i+71); k++){
printf("%c",line[k]);
}
printf("\n");
}
printf("\n");
line.clear();
pattern.clear();
}
int main(){
while(true){
getline(cin,buf);
if(buf == "")break;
func();
}
return 0;
}
|
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, a, b) for(int i = (a); i < int(b); ++i)
#define rep(i, n) REP(i, 0, n)
#define ALL(x) begin(x), end(x)
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
constexpr int NUM = 128;
constexpr int WIDTH = 72;
string line;
while(getline(cin, line)) {
string text = "";
do {
text += line;
} while(getline(cin, line) && !line.empty());
if(text.empty()) break;
string keywords;
getline(cin, keywords);
cin.ignore();
const int n = text.size();
const int m = keywords.size();
vector<int> idx(NUM, -1);
rep(i, m) {
idx[keywords[i]] = i;
}
int number_of_answer = 0;
int shortest = n;
pair<int, int> first_answer;
vector<int> last(m, -1);
rep(i, n) {
if(idx[text[i]] != -1) {
last[idx[text[i]]] = i;
const int start = *min_element(ALL(last));
if(start != -1) {
const int len = i - start;
if(len < shortest) {
shortest = len;
number_of_answer = 1;
first_answer = make_pair(start, i + 1);
}
else if(len == shortest) {
++number_of_answer;
}
}
}
}
cout << number_of_answer << endl << endl;
if(number_of_answer == 0) continue;
for(int i = first_answer.first; i < first_answer.second; i += WIDTH) {
cout << text.substr(i, min(first_answer.second - i, WIDTH)) << endl;
}
cout << endl;
}
return EXIT_SUCCESS;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
using namespace std;
int main() {
while ( true ) {
string t;
string line;
while ( getline( cin, line ) && line.size() ) {
t += line;
}
getline( cin, line );
if ( !line.size() ) break;
string s = line;
getline( cin, line );
map <char, int> need;
for ( string ::iterator it = s.begin(); it != s.end(); it++ ) {
need[*it]++;
}
map <char, int> cnt;
int left = 0, right = 0;
int occ, OCC;
occ = 0;
OCC = need.size();
vector <string> v;
while ( left < t.size() ) {
while ( right < t.size() && occ < OCC ) {
char c = t[right++];
if ( need[c] && need[c] == ++cnt[c] ) ++occ;
}
if ( occ != OCC ) break;
while ( left < right ) {
char c = t[left];
if ( need[c] && need[c] == cnt[c] ) break;
--cnt[c];
left++;
}
if ( left == right ) break;
v.push_back( t.substr( left, right - left ) );
--cnt[t[left++]];
--occ;
}
int mlen = 1<<24;
for ( int i = 0; i < v.size(); i++ ) {
mlen = min( mlen, (int)v[i].size() );
}
int answer1 = 0;
string answer2 = "";
for ( int i = 0; i < v.size(); i++ ) {
if ( v[i].size() == mlen ) {
if ( answer2.size() == 0 ) {
answer2 = v[i];
}
answer1++;
}
}
cout << answer1 << endl;
if ( answer1 > 0 ) cout << endl;
for ( int i = 0; i < answer2.size(); i++ ) {
cout << answer2[i];
if ( (i + 1) % 72 == 0 ) cout << endl;
}
if ( answer2.size() > 0 && answer2.size() != 72 ) cout << endl;
cout << endl;
}
return 0;
}
|
#include<iostream>
#include<map>
#include<cstring>
using namespace std;
const int MAX = 51;
string text, key;
map<char,int> M;
int numKey[MAX];
typedef long long ll;
bool input(){
text = "";
string s = "";
if(!getline(cin,s)) return false;
if(s == "") return false;
text = s;
while(getline(cin,s)&&s!="") text += s;
getline(cin,s);
key = s;
getline(cin,s); // for blank line
return true;
}
void solve(){
memset(numKey,0,sizeof(numKey));
M.clear();
for(int i = 0; i < (int)key.length(); i++)
M[key[i]] = i;
ll need = (1LL<<key.length())-1;
string first = "";
int num = 0;
int s = 0, t = 0;
while(s <= t && t <= (int)text.length()){
if(need == 0){
// if(text.size() > 400 && t-s < 50) cout << text.substr(s,t-s) << endl;
if(first != "" && (int)first.length() == t-s){
num++;
}
if(first == "" || (int)first.length() > t-s){
first = text.substr(s,t-s);
num = 1;
}
if(M.count(text[s]) != 0){
numKey[M[text[s]]]--;
if(numKey[M[text[s]]] == 0) need |= (1LL<<M[text[s]]);
}
s++;
}else{
if(M.count(text[t]) != 0){
if(need&(1LL<<M[text[t]])) need -= (1LL<<M[text[t]]);
numKey[M[text[t]]]++;
}
t++;
}
}
// cout << "min " << minT << endl;
if(num == 0) cout << num << endl;
else{
cout << num << endl << endl;
for(int i = 0; i < (int)first.length(); i++){
cout << first[i];
if((i+1)%72 == 0) cout<<endl;
}
if((int)first.size()%72)cout << endl;
}
cout << endl;
}
int main(){
// bool isFirst = true;
while(input()){
// if(isFirst) isFirst = false;
// else cout << endl;
solve();
}
return 0;
}
|
#include<cstdio>
#include<string>
#include<iostream>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
while(1){
string s,tmp;
while(1){
getline(cin,tmp);
if(tmp=="") break;
s+=tmp;
}
string a; getline(cin,a);
getline(cin,tmp);
if(a=="") break;
int m=a.length();
bool b[128]={};
rep(i,m) b[a[i]]=true;
int n=s.length();
int j_ans,w_ans=2*n,c_ans=0;
int cnt[128]={},cnt2=0;
for(int i=0,j=0;i<n;i++){
if(cnt[s[i]]==0 && b[s[i]]) cnt2++;
cnt[s[i]]++;
if(cnt2==m){
while(j<i && cnt[s[j]]>1 || cnt[s[j]]==1 && !b[s[j]]){
cnt[s[j]]--;
j++;
}
if(i-j+1<w_ans){
j_ans=j;
w_ans=i-j+1;
c_ans=1;
}
else if(i-j+1==w_ans){
c_ans++;
}
}
}
cout<<c_ans<<endl<<endl;
if(c_ans>0){
string ans=s.substr(j_ans,w_ans);
for(int i=0;i<w_ans;i+=72){
for(int j=i;j<min(i+72,w_ans);j++) cout<<ans[j];
cout<<endl;
}
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string S,K;
const int INF=1<<28;
void solve(){
string ans;
int len=INF, cnt=0;
int left=INF;
int idx[K.length()];
// fill(begin(idx), end(idx), 0);
for(int i=0; i<K.length(); ++i)idx[i]=-1;
for(int p=0; p<S.length(); ++p){
for(int k=0; k<K.length(); ++k){
if(S[p]==K[k]){
idx[k]=p;
left=INF;
for(int i=0; i<K.length(); ++i) left=min(left, idx[i]);
if(left>=0){
// cout << left << " " << p << endl;
string cand=S.substr(left, p-left+1);
if(len>cand.length()){
cnt=1;
len=cand.length();
ans=cand;
}else if(len==cand.length()){
++cnt;
}
}
}
}
}
if(len>=INF){
cout << 0 << endl;
}else{
cout << cnt << endl;
cout << endl;
for(int i=0; i<ans.size(); ++i){
if(i>0 && i%72==0) cout<<endl;
cout << ans[i];
}
cout<<endl;
}
cout<<endl;
}
int main(){
for(int cnt=0;;++cnt){
string tmp;
if(getline(cin,tmp).eof()) break;
if(tmp=="") break;
S=tmp;
while(true){
getline(cin,tmp);
if(tmp=="") break;
S+=tmp;
}
getline(cin,K);
getline(cin,tmp);
// cout<<S<<endl;
// cout<<K<<endl;
// if(cnt>0) cout<<endl;
solve();
}
return 0;
}
|
//47
#include<iostream>
#include<sstream>
#include<string>
#include<map>
#include<algorithm>
#include<set>
using namespace std;
int main(){
for(string si;getline(cin,si),si!="";){
string s;
do{
s+=si;
getline(cin,si);
}while(si!="");
string k;
getline(cin,k);
cin.ignore();
map<char,int> m;
int f=0,l=1<<30;
int n=0;
set<long long> st;
for(int i=0;i<s.size();i++){
if(k.find(s[i])!=string::npos){
m[s[i]]=i;
}
if(m.size()!=k.size())continue;
int cl=0,cf=1<<30;
for(int j=0;j<k.size();j++){
cl=max(cl,m[k[j]]);
cf=min(cf,m[k[j]]);
}
if(!st.insert((long long)cl<<32|cf).second)continue;
if(cl-cf<=l-f){
if(cl-cf<l-f){
f=cf;
l=cl;
n=0;
}
n++;
}
}
cout<<n<<endl<<endl;
if(n){
string t=s.substr(f,l-f+1);
for(int i=0;i<t.size();i+=72){
cout<<t.substr(i,72)<<endl;
}
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
string s;
for(;;){
string tmp;
getline(cin, tmp);
if(tmp == "")
break;
s += tmp;
}
int n = s.size();
if(n == 0)
return 0;
string key;
getline(cin, key);
int m = key.size();
vector<bool> isKey(256, false);
for(int i=0; i<m; ++i)
isKey[key[i]] = true;
vector<int> last(256, -1);
set<int> pos;
int num;
int head;
int len = INT_MAX;
for(int i=0; i<n; ++i){
if(isKey[s[i]]){
if(last[s[i]] != -1)
pos.erase(pos.find(last[s[i]]));
last[s[i]] = i;
pos.insert(i);
if(pos.size() == m){
int len2 = i - *(pos.begin()) + 1;
if(len2 < len){
len = len2;
num = 1;
head = *(pos.begin());
}else if(len2 == len){
++ num;
}
}
}
}
if(len == INT_MAX){
cout << '0' << endl;
}else{
cout << num << endl << endl;
while(len > 72){
cout << s.substr(head, 72) << endl;
head += 72;
len -= 72;
}
cout << s.substr(head, len) << endl;
}
cout << endl;
getline(cin, s);
}
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
string str, pat;
vector<char> num;
str.reserve(1000001);
num.reserve(1000001);
pat.reserve(73);
ios::sync_with_stdio(false);
cin.tie(0);
while(true){
str.clear();
pat.clear();
while(true){
getline(cin, pat);
if( pat.empty() || !cin ) break;
str += pat;
}
if( str.empty() || !cin ) break;
getline(cin, pat);
cin.ignore();
sort(pat.begin(), pat.end());
pat.erase( unique(pat.begin(), pat.end()), pat.end());
num.resize(str.size());
int j;
for(j = 0; j < str.size(); ++j){
int x = lower_bound(pat.begin(), pat.end(), str[j]) - pat.begin();
if( x < pat.size() && str[j] == pat[x] ){ num[j] = x; }
else{ num[j] = pat.size(); }
}
int cnt[73] = {};
cnt[pat.size()] = 10000000;
int d = 0;
for(j = 0; j < num.size() && d < pat.size(); ++j){
if( ++cnt[num[j]] == 1 ){
++d;
}
}
if( d < pat.size() ){
cout << "0\n\n";
continue;
}
int a = 0, b = j;
int shortest = 1;
for(int i = 0; j <= num.size(); ){
char x = num[i++];
if( --cnt[x] == 0 ){
bool found = false;
while(j < num.size()){
++cnt[num[j]];
if( x == num[j++] ){
found = true;
break;
}
}
if( !found ) break;
}
if( b - a > j - i ){
a = i;
b = j;
shortest = 1;
}
else if( b - a == j - i ){
++shortest;
}
}
cout << shortest << "\n\n";
while( a < b ){
int len = min(b - a, 72);
cout << str.substr(a, len) << '\n';
a += len;
}
cout << '\n';
}
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int INF=1000000000;
char chs[1001];
int main(){
bool fi=false;
string str;
while(getline(cin,str)&&str!=""){
memset(chs,0,sizeof(chs));
string ss;
string tmp;
if(fi)cout<<endl;
else fi=true;
while(getline(cin,tmp)&&tmp!="")str+=tmp;
while(getline(cin,tmp)&&tmp!="")ss+=tmp;
int sz=INF;
int optHead=0;
int optTail=0;
int head=0;
int tail=-1;
int cnt=0;
while(tail<(int)str.size()){
bool ok=true;
for(int i=0;i<ss.size();i++)if(chs[ss[i]]<=0)ok=false;
// ツ個サツ催敖づ個氾債暗債つェツ適ツ静伉づ按づァ
if(ok){
if(tail-head+1<sz){
optHead=head;
optTail=tail;
sz=tail-head+1;
cnt=1;
}
else if(tail-head+1==sz)cnt++;
chs[str[head]]--;
head++;
}
else{
tail++;
if(tail<(int)str.size())chs[str[tail]]++;
}
}
cout<<cnt<<endl;
if(cnt!=0){
cout<<endl;
for(int i=optHead;i<optHead+sz;i++){
int cn=i-optHead+1;
cout<<str[i];
if(cn%72==0||i==optHead+sz-1)cout<<endl;
}
}
}
cout<<endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
void print_text(const string& text){
int offset = 0;
int text_i = 0;
while(offset < text.size()){
for(text_i = offset; text_i < text.size(); text_i++){
if(text_i - offset >= 72) break;
printf("%c",text[text_i]);
}
printf("\n");
offset += 72;
}
}
void print_co_occurrence(const string& text,const string& query){
int head = 0;
int tail = 0;
int include_keys = 0;
int freq[1024] = {};
bool is_key[1024];
memset(is_key,false,sizeof(is_key));
for(int query_i = 0; query_i < query.size(); query_i++){
is_key[query[query_i]] = true;
}
int min_tail = INF;
int min_len = INF;
int ans_freq = 0;
string ans = "";
while(tail < text.size()){
for(;head < text.size();head++){
if(is_key[text[head]] && !freq[text[head]]++){
include_keys++;
if(include_keys == query.size()){
head++;
break;
}
}
}
for(;tail <= head;tail++){
if(is_key[text[tail]] && !--freq[text[tail]]){
if(include_keys == query.size()) {
if((head -1) - tail + 1 < min_len){
min_len = (head -1) - tail + 1;
ans = text.substr(tail,(head -1) - tail + 1);
ans_freq = 1;
}
else if((head -1) - tail + 1 == min_len){
ans_freq++;
}
}
include_keys--;
tail++;
break;
}
}
}
if(ans_freq == 0){
printf("%d\n",ans_freq);
printf("\n");
}
else{
printf("%d\n",ans_freq);
printf("\n");
print_text(ans);
printf("\n");
}
}
int main(){
string str;
int phase = 0;
string text = "";
string query = "";
while(getline(cin,str)){
if(str.size() == 0){
phase++;
continue;
}
if(phase % 2 == 0){
text += str;
}
else{
query = str;
print_co_occurrence(text,query);
query = "";
text = "";
}
}
}
|
#include<iostream>
#include<string>
#include<vector>
#include<cstdio>
#include<algorithm>
using namespace std;
bool check(int begin, int end, vector<vector<int> > &ind){
if(begin>end)return false;
for(int i = 0; i < (int)ind.size(); ++i){
if(ind[i].size()==0)return false;
vector<int>::iterator it_b = lower_bound(ind[i].begin(),ind[i].end(),begin);
vector<int>::iterator it_e = lower_bound(ind[i].begin(),ind[i].end(),end);
// cout << begin << ' ' << end << ' ' << i << ' ' << it_b-ind[i].begin() << ' ' << it_e-ind[i].begin() << endl;
bool next_b = false;
if(it_b==ind[i].end()){
next_b=false;
}else{
if(begin<=*it_b&&*it_b<=end)next_b=true;
}
bool next_e = false;
if(it_e==ind[i].end())--it_e;
while(it_e!=ind[i].begin()){
if(begin<=*it_e&&*it_e<=end){
next_e = true;
break;
}
--it_e;
}
if(it_e==ind[i].begin()){
if(begin<=*it_e&&*it_e<=end){
next_e=true;
}
}
// cout << next_b << ' ' << next_e << endl;
if(!next_b||!next_e)return false;
}
return true;
}
int main()
{
bool first = true;
while(true){
string text, dam;
while(true){
string tmp;
// if(!getline(cin,tmp))return 0;
getline(cin,tmp);
text+=tmp;
if(tmp.length()==0)break;
}
if(text.length()==0) break;
string key;
getline(cin,key);
getline(cin,dam);
// cout << text.length() <<endl;
//if(first)first=false;
//else puts("");
sort(key.begin(),key.end());
key.erase( unique(key.begin(), key.end()), key.end() );
vector< vector<int> > ind(key.length());
// cout << key << endl;
for(int i = 0; i < (int)text.length();++i){
string::iterator it = lower_bound(key.begin(),key.end(),text[i]);
if(it!=key.end()){
if( *it == text[i] ){
ind[it-key.begin()].push_back(i);
}
}
}
/*
for(int i = 0; i < (int)ind.size(); ++i){
for(int j = 0; j < (int)ind[i].size(); ++j){
cout << ind[i][j] << ' ';
}
cout << endl;
}
cout << "---"<<endl;
*/
int res_cnt = 0;
int res_b = -1;
int res_e = (int)text.length();
for(int x = 0; x < (int)ind.size(); ++x){
for(int i = 0; i < (int)ind[x].size(); ++i){
int begin = ind[x][i];
int left = begin;
int right = text.length();
int end;
// int cnt = 0;
while(left+1<right){
end = (left+right)/2;
if(check(begin,end,ind)){
right = end;
}else left = end;
}
for(int k = -2; k <= 2; ++k){
int tend=end+k;
// cout << begin << ' ' << tend << endl;
if(check(begin,tend,ind)){
if(res_e-res_b>tend-begin){
res_e = tend;
res_b = begin;
res_cnt = 1;
}else if( res_e-res_b==tend-begin){
++res_cnt;
if( begin<res_b){
res_e = tend;
res_b = begin;
}
}
// cout << begin<<' ' <<tend<<' '<<tend-begin<<endl;
break;
}
}
}
}
// cout << res_b << ' ' << res_e << endl;
if(res_cnt==0){
printf("0\n");
}else{
int cnt = 0;
printf("%d\n\n",res_cnt);
for(int i = res_b; i <= res_e; ++i){
putchar(text[i]);
++cnt;
if(cnt==72){putchar('\n');cnt=0;}
}
if(cnt>0){
puts("");
}
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
while(1) {
string s="",t,r;
getline(cin,s);
if(s=="") break;
while(1) {
getline(cin,r);
if(r=="") break;
s+=r;
}
getline(cin,t);
getline(cin,r);
map<char,int> m,d;
m.clear();
d.clear();
for(int i=0; i<t.size(); i++) d[t[i]]=1;
vector<int> v;
for(int i=0; i<s.size(); i++) {
if(d[s[i]]==1) v.push_back(i);
}
int x=0,cnt=0;
string ans=s;
for(int i=0; i<v.size(); i++) {
char c=s[v[i]];
m[c]++;
if(m.size()==t.size()) {
while(m[s[v[x]]]>1) {
m[s[v[x]]]--;
x++;
}
if(ans.size()==v[i]-v[x]+1) {
cnt++;
} else if(ans.size()>v[i]-v[x]+1) {
cnt=1;
ans=s.substr(v[x],v[i]-v[x]+1);
}
}
}
if(cnt==0) cout << cnt << endl;
else {
cout << cnt << endl << endl;
for(int i=0; i<ans.size(); i++) {
cout << ans[i];
if((i+1)%72==0) cout << endl;
}
if(ans.size()%72) cout << endl;
}
cout << endl;
}
return 0;
}
|
#include<iostream>
#include<string>
using namespace std;
int main()
{
string text,key,temp;
for(;;)
{
text=key="";
while(getline(cin,text)&&text.empty())
;
if(cin.eof())return 0;
while(getline(cin,temp)&&!temp.empty())
text+=temp;
if(cin.eof())return 0;
while(getline(cin,key)&&key.empty())
;
if(cin.eof())return 0;
int minLen=1e9,minIndex=1e9,minCount=0;
int i,head,tail;
int kind=0,curKind;
bool f[256]={};
int a[256]={};
for(i=0;i<key.size();++i)
if(!f[key[i]]++)
++kind;
text+="\0";
head=tail=curKind=0;
for(;tail<text.size();)
{
for(; head<text.size(); ++head)
{
char c=text[head];
if(f[c]&&!a[c]++)
{
if(++curKind==kind)
{
++head;
break;
}
}
}
for(; tail<text.size(); ++tail)
{
char c=text[tail];
if(f[c]&&!--a[c])
{
if(curKind--==kind)
{
if(minLen>head-tail)
{
minLen=head-tail;
minIndex=tail;
minCount=1;
}
else if(minLen==head-tail)
++minCount;
++tail;
break;
}
}
}
}
cout<<minCount<<endl<<endl;
if(minLen!=1e9)
{
temp = text.substr(minIndex,minLen);
for(i=0;i<temp.size();++i)
{
cout<<temp[i];
if(i!=temp.size()-1&&i%72==71)cout<<endl;
}
cout<<endl<<endl;
}
}
}
|
/*
000000000011111111112222222222333333333344444444
012345678901234567890123456789012345678901234567
TfefirstemampleistrivivlTfefirstemampleistrifivl
. . .
len = 18 sp = 3
len = 15 sp = 11
len = 12 sp = 22
len = 12 sp = 35
mfv
000000000011111111112222222222
012345678901234567890123456789
aabbccbbccaabbaacceeddffccaabb
. ..
len = 4 sp = 1
abc
*/
#include<set>
#include<iostream>
#include<cmath>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
using namespace std;
void compute(string text,string S)
{
int nt = text.size(),nS = S.size();
int mlen = inf;
string ans;
set<string> all;
bool found[nS];
int CNT = 0;
int fpos[nS];
rep(i,nS)found[i] = false;
rep(i,nt)
{
bool update = false;
int cnt = 0,mn,mx;
mn = inf,mx = -inf;
rep(j,nS)
{
if(S[j] == text[i])
{
update = true;
found[j] = true;
fpos[j] = i;
}
if(found[j])
{
cnt++;
mn = min(mn,fpos[j]);
mx = max(mx,fpos[j]);
}
}
if(cnt == nS)
{
int cost = mx - mn + 1;
if(cost < mlen)
{
mlen = cost;
ans = text.substr(mn,cost);
all.clear();
CNT = 1;
all.insert(text.substr(mn,cost));
}
else if(cost == mlen)
{
if(update)CNT++;
all.insert(text.substr(mn,cost));
}
}
}
cout << CNT << endl << endl;
//printf("%d\n\n",(int)all.size());
if(all.empty())
{
return;
}
rep(i,ans.size())
if((i+1)%72 == 0 && i != 0)
printf("%c\n",ans[i]);
else
printf("%c",ans[i]);
if(ans.size()%72 != 0)puts("\n");
else puts("");
}
int main()
{
string blank;
while(getline(cin,blank))
{
string text,S;
text += blank;
while(getline(cin,blank))
{
if(blank.empty())break;
text += blank;
}
if(text.empty())goto Fin;
while(getline(cin,blank))
if(blank.empty())break;
else S += blank;
compute(text,S);
}
Fin:;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) begin(v), end(v)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
#define min(...) min({__VA_ARGS__})
#define max(...) max({__VA_ARGS__})
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
using pint = pair<int, int>;
using tint = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
string line;
while(getline(cin, line), line != "") {
string s = line, a;
while(getline(cin, line), line != "") s += line;
getline(cin, a);
int n = s.size(), k = a.size();
vint pos[55];
rep(i, n) rep(j, k) {
if(s[i] == a[j]) pos[j].push_back(i);
}
bool imp = false;
rep(i, k) if(!pos[i].size()) imp = true;
if(imp) {
cout << 0 << endl << endl;
getline(cin, line);
continue;
}
int idx[55] = {};
int ans = 0, head = 0, len = n;
rep(i, n) {
int tail = i;
rep(j, k) chmax(tail, pos[j][idx[j]]);
if(tail-i+1 < len) ans = 0, head = i, len = tail-i+1;
if(tail-i+1 == len) ans++;
int p = a.find(s[i]);
if(p != -1) {
idx[p]++;
if(idx[p] >= pos[p].size()) break;
}
}
string t = s.substr(head, len);
cout << ans << endl;
rep(i, t.size()) {
if(i%72 == 0) cout << endl;
cout << t[i];
}
cout << endl << endl;
getline(cin, line);
}
return 0;
}
|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
#define rep(i, n) for ( int i = 0; i < (int)n; i++)
bool T[256];
int P[256];
vector<string> compute(string text, string key){
vector<string> ans;
int k = key.size();
rep(i, 256) P[i] = -1;
int l = text.size();
int r = -1;
rep(i, 256) T[i] = false;
rep(i, k) T[key[i]] = true;
rep(i, k){
rep(j, text.size()){
if ( key[i] == text[j] ) {
P[key[i]] = j;
l = min(l, j);
r = max(r, j);
break;
}
}
}
rep(i, k) if ( P[key[i]] == -1 ) return ans;
for ( int i = l; i <= r; i++ ){
if ( T[text[i]] ){
if ( P[text[i]] < i ) P[text[i]] = i;
}
}
ans.push_back(text.substr(l, r-l+1));
for ( int i = r+1; i < text.size(); i++ ){
char ch = text[i];
if ( T[ch] ){
r = i;
P[ch] = i;
l = r;
rep(t, k){
if ( T[key[t]] ){
l = min(l, P[key[t]]);
}
}
string c = text.substr(l, r-l+1);
if ( ans[0].size() == c.size() ) ans.push_back(c);
else if ( ans[0].size() > c.size() ){
ans.clear();
ans.push_back(c);
}
}
}
return ans;
}
void output(string line){
rep(i, line.size()){
if ( i % 72 == 0 && i != 0 ) cout << endl;
cout << line[i];
}
cout << endl;
}
int main(){
string text, line, key;
while(1){
text = "";
while(1){
getline(cin, line);
if ( line.size() == 0 ) break;
text += line;
}
if ( text == "" ) break;
getline(cin, key);
getline(cin, line);
vector<string> ans = compute(text, key);
cout << ans.size() << endl;
if ( ans.size() > 0 ){
cout << endl;
output(ans[0]);
}
cout << endl;
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
vector<int> after(n+2, 0);
for(int i=0; i<m; i++){
int c,d;
cin >> c >> d;
after[c] = max(after[c], d);
}
int ans = 0;
int farthest = 0;
for(int i=0; i<=n; i++){
farthest = max(farthest, after[i]);
if(farthest > i){
ans += 3;
}else{
ans += 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <cstdio>
int N, M;
int imos[1010];
int main() {
scanf("%d%d", &N, &M);
for(int i=0; i<M; i++) {
int l, r; scanf("%d%d", &l, &r);
imos[l]++;
imos[r]--;
}
for(int i=1; i<=N; i++) {
imos[i] += imos[i-1];
}
int prev = -1, ans = N + 1;
for(int i=1; i<=N+1; i++) {
if( imos[i] && prev < 0) prev = i;
if(!imos[i] && prev >= 0) {
// printf("l = %d, r = %d\n", prev, i);
ans += 2 * (i - prev);
prev = -1;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#define phb push_back
#define mkp make_pair
#define frs first
#define scn second
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef pair< int, int > Pr;
int N, M;
vector< Pr > C;
void read();
void solve();
bool cmpf(const Pr &, const Pr &);
int main() {
read();
solve();
return 0;
}
void read() {
int c, d;
cin >> N >> M;
for (int i = 0; i < M; ++i) {
cin >> c >> d;
C.phb(mkp(c, d));
}
}
void solve() {
vector< Pr > cp;
for (int i = 0; i < M; ++i) {
bool ign = false;
for (int j = 0; j < M && !ign; ++j)
if (i != j && ((C[i].frs >= C[j].frs) && (C[i].scn <= C[j].scn)))
ign = true;
if (!ign)
cp.phb(C[i]);
}
stable_sort(all(cp), cmpf);
int res = N + 1;
for (int i = 0, j = 0, ed; i < sz(cp); i = j) {
j = i + 1, ed = cp[i].scn;
while (j < sz(cp) && (ed >= cp[j].frs))
ed = cp[j].scn, ++j;
res += 2 * (ed - cp[i].frs);
}
cout << res << "\n";
}
bool cmpf(const Pr &ra, const Pr &rb) {
return ra.frs < rb.frs;
}
|
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <functional>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define SQ(x) ((x)*(x))
#define Mod(x, mod) (((x)+(mod)%(mod))
#define MP make_pair
#define PB push_back
#define Fi first
#define Se second
#define INF (1<<29)
#define EPS 1e-10
#define MOD 1000000007
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int st[1024];
int main()
{
int N, m;
cin >> N >> m;
rep(i, m){
int c, d; cin >> c >> d;
st[c]++;
st[d]--;
}
rep(i, N) st[i+1] += st[i];
int res = 0;
rep(i, N+1)
if(st[i+1]) res += 3;
else res += 1;
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cstdio>
#include <ctime>
#include <assert.h>
#include <chrono>
#include <random>
#include <numeric>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
return (ull)rng() % B;
}
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n,m; cin >> n >> m;
vector<int> a(n+2);
while(m--){
int x,y; cin >> x >> y;
a[x]++;
a[y]--;
}
for(int i=1;i<=n;i++){
a[i]+=a[i-1];
}
int res=n+1;
for(int i=1;i<=n;i++){
if(a[i]>=1)res+=2;
}
printf("%d\n",res);
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int dfs(int n, vector<vector<int> >& adj){
if((int)adj[n].size() == 0) return n;
int ret=0;
for(int i=0; i<(int)adj[n].size(); i++){
ret = max(ret, dfs(adj[n][i], adj));
}
adj[n].clear();
return ret;
}
int main(){
int n,m;
cin >> n >> m;
vector<vector<int> > need(n+1);
for(int i=0; i<m; i++){
int c,d;
cin >> c >> d;
need[c].push_back(d);
}
vector<int> c,d;
for(int i=1; i<=n; i++){
int top = dfs(i, need);
if(top != i){
c.push_back(i);
d.push_back(top);
}
}
c.push_back(n+1);
d.push_back(n+1);
int ans = 0;
int s=c[0], e=d[0];
for(int i=1; i<(int)c.size(); i++){
if(c[i] <= e){
e = max(e, d[i]);
}else{
ans += e-s;
s = c[i];
e = d[i];
}
}
ans = n +1 +ans*2;
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
int main(){
int n,m;
cin >> n >> m;
vector<pii> r(m);
for(int i=0;i<m;i++)cin >> r[i].first >> r[i].second;
sort(r.begin(),r.end());
int s=-1,t=-1,sum=0;
for(int i=0;i<m;i++){
if(r[i].first<=t){
t = max(t, r[i].second);
}else{
sum += t-s;
s = r[i].first, t = r[i].second;
}
}
sum += t-s;
cout << n+1 + 2*sum << endl;
}
|
#include<iostream>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
#include<functional>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cassert>
#include<ctime>
using namespace std;
#define mind(a,b) (a>b?b:a)
#define maxd(a,b) (a>b?a:b)
#define absd(x) (x<0?-(x):x)
#define pow2(x) ((x)*(x))
#define rep(i,n) for(int i=0; i<n; ++i)
#define repr(i,n) for(int i=n-1; i>=0; --i)
#define repl(i,s,n) for(int i=s; i<=n; ++i)
#define replr(i,s,n) for(int i=n; i>=s; --i)
#define repf(i,s,n,j) for(int i=s; i<=n; i+=j)
#define repe(e,obj) for(auto e : obj)
#define SP << " " <<
#define COL << " : " <<
#define COM << ", " <<
#define ARR << " -> " <<
#define PNT(STR) cout << STR << endl
#define POS(X,Y) "(" << X << ", " << Y << ")"
#define DEB(A) " (" << #A << ") " << A
#define DEBREP(i,n,val) for(int i=0; i<n; ++i) cout << val << " "; cout << endl
#define ALL(V) (V).begin(), (V).end()
#define INF 1000000007
#define INFLL 1000000000000000007LL
#define EPS 1e-9
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
#define P_TYPE int
typedef pair<P_TYPE, P_TYPE> P;
typedef pair<P, P_TYPE> PI;
typedef pair<P_TYPE, P> IP;
typedef pair<P, P> PP;
typedef priority_queue<P, vector<P>, greater<P> > pvqueue;
#define N 1003
int n, m;
int cnt[N];
int main() {
cin >> n >> m;
rep(i, m) {
int c, d;
cin >> c >> d;
cnt[c-1] += 1;
cnt[d-1] -= 1;
}
int ans = n + 1;
int cur = 0, fst = 0;
rep(i, n) {
if(cur == 0 && cnt[i] > 0) {
fst = i;
}
cur += cnt[i];
if(cnt[i] < 0 && cur == 0) {
ans += (i - fst) * 2;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <functional>
using namespace std;
#define Rep(b, e, i) for(int i = b; i <= e; i++)
#define Repr(e, b, i) for(int i = e; i >= b; i--)
#define rep(n, i) Rep(0, n-1, i)
#define repr(n, i) Repr(n-1, 0, i)
#define all(v) (v).begin(), (v).end()
#define pb(x) push_back(x)
#define uniq(x) (x).erase(unique(all(x)),(x).end())
typedef long long ll;
typedef pair<ll, ll> llP;
typedef pair<int, int> intP;
typedef std::priority_queue<int> IntPrioQueue; //Z->A
typedef std::priority_queue<int, std::vector<int>, std::greater<int> > IntReversePrioQueue; //A->Z
const int MAX = 1024;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1<<29;
const int MOD = 1000000007;
int step[MAX];
void solve(void){
int N, m;
cin >> N >> m;
//累積和を用いることでO(N)に計算量が落とせる
//半開区間[a, b)で持つ
rep(m, i) {
int a, b;
scanf("%d %d\n", &a, &b);
a--; b--;
step[a]++;
step[b]--;
}
rep(N, i) step[i+1] += step[i];
int dis = 0, ans = 0;
rep(N+1, n) {
if (step[n] > 0) dis++;
else {
ans += dis;
dis = 0;
}
}
ans = ans*2+1+N;
cout << ans << '\n';
}
int main(void){
solve();
return 0;
}
|
#include "bits/stdc++.h"
#define REP(i,n) for(ll i=0;i<n;++i)
#define RREP(i,n) for(ll i=n-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<n;++i)
#define RFOR(i,m,n) for(ll i=n-1;i>=m;--i)
#define ALL(v) (v).begin(),(v).end()
#define PB(a) push_back(a)
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define DUMP(v) REP(aa, (v).size()) { cout << v[aa]; if (aa != v.size() - 1)cout << " "; else cout << endl; }
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
const int dy[8] = { 0,1,1,1,0,-1,-1,-1 };
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
///(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)///
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<pii> v(m);
REP(i, m)cin >> v[i].first >> v[i].second;
sort(ALL(v));
int ans = n + 1;
int c = 0, d = 0;
REP(i, m) {
if (v[i].first > d) {
ans += 2 * (d - c);
c = v[i].first;
d = v[i].second;
}
else d = max(d, v[i].second);
}
ans += 2 * (d - c);
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, m;
cin >> N >> m;
vector<bool> b(N);
for (int i = 0; i < m; ++ i) {
int c, d;
cin >> c >> d;
-- c; -- d;
for (int j = c; j < d; ++ j) {
b[j] = true;
}
}
int r = N+1;
for (int i = 0; i < N; ++ i) if (b[i]) r += 2;
cout << r << endl;
}
|
#include <iostream>
using namespace std;
int main() {
int n,d,flg[1002]={};
cin >> n >> d;
for(int i=0;i<d;i++) {
int a,b;
cin >>a>>b;
flg[a] = max(flg[a],b);
}
int sta=0,sum=0,L=0,R=0;
for(int i=0;i<=n;i++) {
if(flg[i] != 0 && sta==1) R=max(R,flg[i]);
else if(flg[i] != 0) L=i,R=flg[i],sta=1;
else if(i==R) sum += 3*(R-L)+1,sta=0;
else if(sta==0) sum++;
}
cout << sum <<endl;
return 0;
}
|
#include <cstdio>
#include <cmath>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
using namespace std;
typedef long long LL;
int n,m,x,y;
vector<int> v[1005];
int a[1005];
int ans,dq,len,nxt;
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=m;++i)
{
scanf("%d%d",&x,&y);
v[x].push_back(y);
}
for (int i=1;i<=n;++i) a[i]=i;
for (int i=n;i>=1;--i)
{
for (int j=0;j<v[i].size();++j)
{
a[i]=max(a[i],a[v[i][j]]);
}
}
ans=1;dq=1;
while (dq<=n)
{
nxt=a[dq];len=0;
for (int i=dq+1;i<=nxt;++i)
{
len++;nxt=max(nxt,a[i]);
}
ans+=3*len;
ans++;
dq=nxt+1;
}
printf("%d\n",ans);
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
struct ioi{
int l,r;
} seg[510];
int n, m;
bool intersect(ioi a,ioi b){
if (a.l>b.l) swap(a,b);
if (b.l<=a.r) return true;
else return false;
}
ioi combine(ioi a,ioi b){
a.l = min(a.l, b.l);
a.r = max(a.r, b.r);
return a;
}
int main(){
cin >> n >> m;
for (int i=1;i<=m;i++)
cin >> seg[i].l >> seg[i].r;
long long res = n+1;
sort(seg+1, seg+m+1,[](ioi a,ioi b){
return (a.l<b.l or (a.l==b.l and a.r>b.r));
});
ioi current_segment = seg[1];
for (int i=1;i<=m;i++){
if (intersect(seg[i], current_segment)){
current_segment = combine(current_segment, seg[i]);
}
else{
res += 2*(current_segment.r - current_segment.l);
current_segment = seg[i];
}
}
res += 2*(current_segment.r - current_segment.l);
cout << res << "\n";
}
|
#define D(x) cout << #x " = " << x << endl
#define DD(x, y) cout << "(" #x ", " #y ") = (" << x << ", " << y << ")" << endl
#define DDD(x, y, z) cout << "(" #x ", " #y ", " #z ") = (" << x << ", " << y << ", " << z << ")" << endl
#define DV(v) for (auto __macro_vi : v){ cout << __macro_vi << " ";} cout << endl;
#define DA(a, n) for (int __macro_i = 0; __macro_i < n; ++__macro_i) { cout << a[__macro_i] << " "; } cout << endl;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) (v).begin(), (v).end()
#include<iostream>
#include<vector>
#include<cassert>
#include<cmath>
#include<algorithm>
template<class T, class U> std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p){ os << "(" << p.first << ", " << p.second << ")"; return os; }
using namespace std;
using P = pair<int, int>;
int n, m;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
vector<P> revs(0);
REP(i, m) {
int aft, pre;
cin >> aft >> pre;
revs.emplace_back(aft, pre);
}
sort(ALL(revs));
int pos = 0;
int ans = 0;
int k = 0;
while(k < revs.size()) {
// DD(k, pos);
int pre = revs[k].second;
int aft = revs[k].first;
// DD(pre, aft);
while(k+1 < revs.size() && revs[k+1].first < pre) {
k++;
pre = max(pre, revs[k].second);
// DD("contains", k);
}
ans += pre - pos + (pre - aft) * 2;
// D(pre - pos + (pre - aft) * 2);
pos = pre;
k++;
}
ans += n + 1 - pos;
cout << ans << endl;
}
|
#include <cstdio>
using namespace std;
int s[1010][2],n,m,ans;
int f[1010];
int min(int a,int b){
return a<b?a:b;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++){
scanf("%d%d",&s[i][0],&s[i][1]);
//s[i][0]--;]s[i][1]--;
}
for(int i=0;i<m;i++){
for(int j=i+1;j<m;j++){
if(s[j][1]<s[i][1]||(s[j][1]==s[i][1]&&s[j][0]<s[i][0])){
for(int k=0;k<2;k++){
int c=s[i][k];
s[i][k]=s[j][k];
s[j][k]=c;
}
}
}
}
for(int i=0;i<m;i++){
f[i]=100*n*n;
int minc=s[i][0];
for(int j=i-1;j>=0;j--){
f[i]=min(f[i],f[j]+(s[i][1]-s[j][1])+2*(s[i][1]-minc));
minc=min(minc,s[j][0]);
}
f[i]=min(f[i],s[i][1]+2*(s[i][1]-minc));
}
printf("%d\n",f[m-1]+(n+1-s[m-1][1]));
}
|
#include <cstdio>
int main(){
int n,m;
int sum[1010] ={};
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
sum[a-1]++;
sum[b-1]--;
}
int ans=0;
for(int i=0;i<n;i++){
sum[i+1] += sum[i];
ans += !!sum[i] * 2;
}
printf("%d\n",ans+(n+1));
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int,int> P;
P t[1002];
int main() {
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < m; i++) {
cin >> t[i].first >> t[i].second;
}
sort(t, t + m);
vector<P> v;
for (int i = 0; i < m; i++) {
int lft = t[i].first;
int rht = t[i].second;
int j = i + 1;
while (j < m && lft <= t[j].first && t[j].first <= rht) {
rht = max(rht, t[j].second);
j++;
}
v.push_back(P(lft, rht));
i = j - 1;
}
int ans = 0;
int now = 0;
for (int i = 0; i < v.size(); i++) {
ans += abs(now - v[i].second);
ans += v[i].second - v[i].first;
now = v[i].first;
}
ans += (n + 1) - now;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vec;
int main () {
int N, m; cin >> N >> m;
vec c(m), d(m);
for (int i = 0; i < m; i++) {
cin >> c[i] >> d[i];
}
vec h(N + 1);
for (int i = 0; i < m; i++) {
if (c[i] < d[i]) {
for (int j = c[i] + 1; j <= d[i]; j++) {
h[j] = 1;
}
}
}
int res = N + 1;
for (int i = 1; i <= N; i++) {
if (h[i]) {
res += 2;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,m;
cin>>n>>m;
vector<int> s(n+1,0);
for(int i=0;i<m;i++){
int a,b; cin>>a>>b;
s[a]++; s[b]--;
}
partial_sum(s.begin(),s.end(),s.begin());
cout<< n+1+ (n+1-count(s.begin(),s.end(),0))*2 <<endl;
}
|
// Author :
// Date :
// Problem:
// Solution:
// Comment:
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstring>
#define pp push
#define pb push_back
#define mp make_pair
#define xx first
#define yy second
using namespace std;
void play(int n , int c){
int mas[1005]={0};
int lock[1005] = {0};
int cur = 0;
int left = 0;
int maxx = -1;
int minn = -1;
int step = 0;
int a,b;
for(int i = 0 ; i < c ; i++){
cin >> a >> b;
if(lock[a] < b){
lock[a] = b;
}
}
//cout << cur << endl;
while(cur < n+1){
//cout << cur << endl;
if(lock[cur] != 0 && lock[cur] > maxx) maxx = lock[cur];
if(lock[cur] != 0 && minn == -1) minn = cur;
if(cur == maxx){
while(cur > minn){
cur--;
lock[cur] = 0;
//cout << "minn " << minn << endl;
//cout << cur << endl;
step++;
}
maxx = -1;
minn = -1;
}
cur++;
step++;
}
cout << step << endl;
}
int main(){
int a,b;
cin >> a >> b;
play(a,b);
#ifdef GEREL
for(;;);
#endif
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N,m; cin >> N >> m;
vector<pair<int,int>> pos;
for (int i=0;i<m;++i){
int c,d; cin >> c >> d;
pos.emplace_back(c,d);
}
pos.emplace_back(N+1,N+1);
sort(pos.begin(),pos.end());
int l=0,r=0,ans=N+1;
for (int i=0;i<m+1;++i){
if (r<pos[i].first) ans+=2*(r-l),l=pos[i].first;
r=max(r,pos[i].second);
}
cout << ans << '\n';
}
|
//
// Created by 拓真 on 2018/06/24.
//
#include "bits/stdc++.h"
using namespace std;
int x[11234];
int main(){
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++)x[i]=1;
for(int i=0;i<m;i++){
int c,d;
cin>>c>>d;
for(int j=c;j<d;j++){
x[j]=3;
}
}
int ans=0;
for(int i=0;i<n;i++){
ans+=x[i];
}
cout<<ans+1<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<int> pos(n+1,1);
for(int i=0;i<m;i++){
int c,d;
cin>>c>>d;
for(int j=c;j<d;j++) pos[j]=3;
}
cout<<accumulate(pos.begin(),pos.end(),0)<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int v[1001] = {};
for ( long long int i = 0; i < m; i++ ) {
long long int in_c, in_d;
cin >> in_c >> in_d;
v[ in_c ]++;
v[ in_d ]--;
}
for ( long long int i = 1; i <= n; i++ ) {
v[i] += v[i-1];
}
long long int ans = 0;
for ( long long int i = 0; i <= n; i++ ) {
if ( v[i] == 0 ) {
ans += 1;
}else {
ans += 3;
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define pb emplace_back
#define xx first
#define yy second
using namespace std;
typedef pair<int, int>pi;
vector<pi>vec;
bool vis[1003];
int main()
{
int n, m, x, y;
while(scanf("%d %d", &n, &m)==2)
{
vec.clear();
for(int i=0; i<m; i++)
{
scanf("%d %d", &x, &y);
vec.pb(x, y);
}sort(vec.begin(), vec.end());
memset(vis, 0, sizeof vis);
int ans= 0, c= 0, temp= 0;
for(int i=0; i<m; i++)
if(!vis[i])
{
int l= vec[i].xx;
int r= vec[i].yy;
while(i<m)
{
if(vec[i].xx>r)break;
r= max(r, vec[i].yy);
vis[i]= 1;
i++;
}i--;
ans+= (r-l); temp+= (r-l+1);c++;
}
ans= ((n-temp)+c+1) +(ans*3);
printf("%d\n", ans);
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n, m, answer = 0;
cin >> n >> m;
bool flag = 0;
int start_point;
vector<int> shop_gap(n + 1, 0);
for (int i = 0; i < m; i++)
{
int c, d;
cin >> c >> d;
for (int j = c; j < d; j++)
{
shop_gap.at(j)++;
}
}
for (int i = 0; i < n + 1; i++)
{
if (shop_gap.at(i) != 0 && flag == 0)
{
flag = 1;
start_point = i;
}
else if (shop_gap.at(i) == 0 && flag == 1)
{
flag = 0;
answer += 2 * (i - start_point);
}
}
answer += n + 1;
cout << answer << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
int gcd(int a, int b){
if(b==0) return a;
return gcd(b,a%b);
}
int lcm(int a, int b){
return a*b/gcd(a,b);
}
int main(void) {
int i,j;
int n,m;
cin >> n >> m;
vi imos(n+1,0);
rep(i,m){
int a,b;
cin >> a >> b;
imos[a]++;
imos[b]--;
}
rep(i,n)imos[i+1]+=imos[i];
int ans = 0;
rep(i,n+1){
ans++;
if(imos[i])ans+=2;
}
cout << ans << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cstdio>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PLL;
int main() {
int N, M;
int c[500], d[500];
cin >> N >> M;
for (int j = 0 ; j < M; ++j) {
cin >> c[j] >> d[j];
}
int arr[1010];
fill(arr, arr+1010, 0);
for (int j = 0; j < M; ++j) {
--arr[c[j]];
++arr[d[j]];
}
for (int j = 1; j < N+1; ++j) {
arr[j] += arr[j-1];
}
int ret = 0;
for (int j = 1; j <= N+1; ++j) {
if (arr[j] == 0) {
++ret;
} else {
ret += 3;
}
}
cout << ret << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#define f first
#define s second
using namespace std;
int n,m;
int main(){
cin >> n >> m;
vector<int> vec(n+2,0);
for(int i = 0;i < m;i++){
int f,t;
cin >> t >> f;
vec[t]++;
vec[f]--;
}
for(int i = 0;i < n+1;i++){
vec[i+1] += vec[i];
}
int ans = 0;
for(int i = 0;i < n+2;i++){
if(vec[i])ans++;
}
cout << n+1+ans*2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
#define INF INT_MAX/3
#define MAX_N 1000
int n,m;
bool used[1111];
int main(){
cin.sync_with_stdio(false);
cin>>n>>m;
rep(i,m){
int c,d;
cin>>c>>d;
c--; d--;
repl(i,c,d){
used[i]=true;
}
}
int l=-1;
int cnt=0;
rep(i,n+1){
if(l==-1&&used[i]){
l=i;
}else if(l!=-1&&!used[i]){
cnt+=(i-l);
l=-1;
}
}
cout<<n+1+cnt*2<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> shop(n + 1, false);
for (int i = 0; i < m; i++) {
int c, d;
cin >> c >> d;
for (int j = c; j < d; j++) shop[j] = true;
}
int ans = 0;
for (int i = 0; i < n + 1; i++) {
if (shop[i]) ans += 2;
}
cout << ans + n + 1 << endl;
return 0;
}
|
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
const int MAX_N = 1010;
int N, M;
int cnt[MAX_N];
int main() {
cin >>N >>M;
memset(cnt, 0, sizeof(cnt));
REP(i, M){
int s, t; cin >>s >>t;
++cnt[s];
--cnt[t];
}
FOR(i, 1, MAX_N) cnt[i] += cnt[i - 1];
int ans = 0;
FOR(i, 1, N + 2) ans += (cnt[i] > 0 ? 3 : 1);
cout <<ans <<endl;
return 0;
}
|
//#include<bits/stdc++.h>
#include<iostream>
#include<iomanip>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<numeric>
#include<bitset>
#include<limits>
#include<unordered_map>
#include<functional>
using namespace std;
#define rep(i,s,n) for(int i=s;i<n;i++)
#define dow(i,n,s) for(int i=n-1;i>=s;i--)
#define all(a) a.begin(),a.end()
#define Sort(a) sort(all(a))
#define Qsort(a,size) qsort(a,size,sizeof(*a),compare_int)
#define DEBUG
typedef pair<int,int> II;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
bool compare_int(const void *a,const void *b) { return *(int *)a-*(int *)b; }
bool compare_by_second(II a,II b) { return a.second!=b.second?a.second<b.second:a.first<b.first; }
const int INF = 1e+9;
const int MAX_N = 1e+3;
const int MAX_M = 5e+2;
int N,m;
int c,d;
int cd[MAX_N+1];
int mn = INF,mx = 0,res = 0;
int bmx = 0;
bool flag;
int main() {
cin>>N>>m;
memset(cd,-1,sizeof(cd));
rep(i,0,m) {
cin>>c>>d;
cd[c] = max(cd[c],d);
}
rep(i,0,N+1) {
if(cd[i] > mx) mx = cd[i];
if(cd[i] != -1) {
mn = min(i,mn);
cd[i] = -1;
}
if(i != 0 && i == mx) {
res += (3*mx-2*mn-bmx);
bmx = mx;
flag = true;
rep(j,i+1,N+1) {
if(cd[j] != -1) { flag = false; break; }
}
if(flag) break;
mx = 0;
mn = INF;
}
}
res+=(N+1-mx);
cout<<res<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n, m, i, f[1002] = {0};
cin >> n >> m;
for (i = 0; i < m; i++) {
int c, d;
cin >> c >> d;
f[c]++;
f[d]--;
}
int ans = n + 1;
for (i = 1; i < n + 2; i++) {
f[i] += f[i - 1];
if (f[i]) ans += 2;
}
cout << ans << endl;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
//#define int int64_t
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0,a1,a2,a3,x,...) x
#define REP1(i, s, cond, cal) for (signed i = signed(s); i cond; i cal)
#define REP2(i, s, n) REP1(i, s, < signed(n), ++)
#define REP3(i, n) REP2(i, 0, n)
#define rep(...) CHOOSE((__VA_ARGS__,REP1,REP2,REP3))(__VA_ARGS__)
#define rrep(i, s) rep(i, s, >= 0, --)
#define all(c) begin(c), end(c)
#define maxup(ans, x) (ans = (ans < x ? x : ans))
#define minup(ans, x) (ans = (ans > x ? x : ans))
#define breakif(cond) if(cond) break; else
using VV = vector<vector<int>>;
using V = vector<int>;
using P = pair<int, int>;
using IP = pair<int, P>;
template<typename T>
inline void input(vector<T>& v) { for (auto& x : v) cin >> x; }
signed main() {
int n, m;
while (cin >> n >> m) {
V imos(n + 1);
rep(i, m) {
int c, d;
cin >> c >> d;
int a = n - d, b = n - c;
imos[a]++;
imos[b]--;
}
rep(i, 1, n + 1) imos[i] += imos[i - 1];
int ans = n + 1;
rep(i, n) ans += !!imos[i] * 2;
cout << ans << endl;
}
}
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
int DP[2000] = {};
int main(){
int N, M;
cin >> N >> M;
for(int i = 0; i < M; i++){
int c, d;
cin >> c >> d;
DP[c]++;
DP[d]--;
}
int ans = N + 1;
int cur = 0;
for(int i = 0; i <= N + 1; i++){
cur += DP[i];
if(cur > 0){
ans += 2;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
vector<pair<int, int>> cd;
int N, m, c, d;
cin >> N >> m;
int ans = N + 1;
for(int i = 0; i < m; ++i){
cin >> c >> d;
cd.push_back({c, d});
}
sort(cd.begin(), cd.end());
int start = 0, end = 0;
for(int i = 0; i < m; ++i){
if(start == 0){
start = cd[i].first;
}
if(cd[i].first <= end || end == 0){
if(cd[i].second > end){
end = cd[i].second;
}
}else{
ans += 2 * (end - start);
start = cd[i].first;
end = cd[i].second;
}
}
ans += 2 * (end - start);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> imos(n + 2, 0);
REP(i, m) {
int c, d;
cin >> c >> d;
imos[c]++;
imos[d]--;
}
REP(i, n + 1) imos[i + 1] += imos[i];
int ans = n + 1;
REP(i, n + 2) {
if (imos[i] > 0) ans += 2;
}
cout << ans << endl;
}
|
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <bitset>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
#define INF 1000000000
int main(){
int n,m;
cin>>n>>m;
vector<int> shops(n,0);
rep(i,m){
int c,d;
scanf("%d %d", &c,&d);
shops[c-1]++;
shops[d-1]--;
}
repl(i,1,n){
shops[i] += shops[i-1];
}
int res=n+1;
bool flg=false;
int start;
rep(i,n){
if((!flg) && shops[i]>0){
flg=true;
start=i;
}
else if(flg && shops[i]==0){
flg=false;
res += (i-start)*2;
}
}
cout << res << endl;
return 0;
}
|
#include <stdio.h>
#include <cctype>
#include <limits.h>
#include <math.h>
#include <complex>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
#define X first
#define Y second
const int INF = 1e9;
const double EPS = 1e-8;
const double PI = 3.14159;
int dx[4]={0, 1, 0, -1}, dy[4]={-1, 0, 1, 0};
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
/* struct P {
int x, y, n;
P(int n, int x, int y):n(n), x(x), y(y){}
P(){}
}; */
/** Problem1347 : Shopping **/
int main()
{
int N, m;
cin>>N>>m;
vector<P> list(m);
rep(i, m) {
cin>>list[i].first>>list[i].second;
}
bool repeat[1000] = {0};
rep(i, m) {
for (int j=list[i].first; j<list[i].second; j++) {
repeat[j] = true;
}
}
int ans=N+1;
rep(i, 1000) {
if (repeat[i]) ans+=2;
}
cout << ans << endl;
}
|
#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
signed main(void)
{
int n, m;
cin >> n >> m;
vector<PII> v;
REP(i, m) {
int c, d;
cin >> c >> d;
if(c < d) v.PB({d, c});
}
sort(ALL(v));
if(v.size() == 0) {
cout << n+1 << endl;
return 0;
}
int ret = n+1;
for(int i=0; i<m; ++i) {
// cout << "i:" << i << endl;
int l = v[i].second, r = v[i].first;
int idx = i;
for(int j=i+1; j<m; ++j) {
if(v[j].second <= r) {
r = v[j].first;
chmin(l, v[j].second);
idx = j;
}
// cout << l << " " << r << " " << idx << endl;
}
ret += (r-l)*2;
i = idx;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
//#define LOG(...)
#define FOR(i, a, b) for(int i=(int)(a); i<(int)(b); ++i)
#define REP(i, n) for(int i=0; i<(int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
int N, m;
cin >> N >> m;
vi shop(N+1);
REP(i, m){
int c, d;
cin >> c >> d;
shop[c-1]++;
shop[d-1]--;
}
int res = N + 1;
int cnt = 0;
int start = -1;
REP(i, N){
if(shop[i] == 0) continue;
cnt += shop[i];
if(start == -1) start = i;
if(cnt == 0) {
res += (i - start) * 2;
start = -1;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long int N , M , ans = 0;
cin >> N >> M;
vector<int>data((N + 2)*2);
for(size_t i = 0; i < M; i++)
{
int a , b;
cin >> a >> b;
if(b > a)
{
data[a*2]++;
data[b*2+1]--;
}
}
for(size_t i = 1; i < (N + 2)*2; i++)
{
data[i] += data[i - 1];
}
ans += N + 1;
long long int begin = 0 , end;
bool flag = 0,flag2=0;
for(size_t i = 0; i < (N + 2)*2; i++)
{
if(data[i] > 0)
{
flag = 1;
}
if(data[i] == 0)
{
if(flag)
{
flag = 0;
ans += ( i - begin - 2 ) ;
}
begin = i;
}
}/*
for(size_t i = 0; i < (N + 2)*2; i++)
{
cout << data[i] << " ";
}
cout << endl;*/
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=a;i<b;++i)
#define allof(a) a.begin(),a.end()
typedef pair< int, int > pii;
int N, m;
int main() {
cin >> N >> m;
vector< pii > vp;
for_(i,0,m) {
int c, d; cin >> c >> d;
vp.push_back(pii(c,d));
}
sort(allof(vp));
vector< pii > vvp;
int ans = 0, s = 0, a = 0, b = 0;
for_(i,0,m) {
if (a <= vp[i].first && vp[i].first <= b) {
a = min(a, vp[i].first);
b = max(b, vp[i].second);
} else {
ans += (b - s) + 2 * (b - a);
s = b;
a = vp[i].first;
b = vp[i].second;
}
}
ans += (b - s) + 2 * (b - a) + N + 1 - b;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
constexpr int MAX_N = 1000;
int n, m;
cin >> n >> m;
bitset<MAX_N> back;
for(int i = 0; i < m; ++i) {
int c, d;
cin >> c >> d;
if(c > d) continue;
for(int j = c; j < d; ++j) {
back[j] = true;
}
}
cout << n + 1 + back.count() * 2 << endl;
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
int main() {
for (int n, m; scanf("%d%d", &n, &m) == 2; ) {
vector<int> a(n + 1, 0);
for (int i = 0; i < m; ++ i) {
int u, v; scanf("%d%d", &u, &v);
a[u] ++; a[v] --;
}
int ret(0);
for (int i = 1; i <= n; ++ i) {
a[i] += a[i - 1];
if (a[i]) ret ++;
}
ret = ret * 2 + n + 1;
printf("%d\n", ret);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
vector<int> G[1111];
int N,M;
int main(){
cin >> N >> M;
for(int i=0;i<M;i++){
int c,d;
cin >> c >> d;
if( c < d ) G[c].push_back(d);
}
int res = 0;
for(int i=1;i<=N+1;i++){
int rmax = i;
if( G[i].empty() ){
res ++; continue;
}
for(int j=0;j<(int)G[i].size();j++) rmax = max( rmax, G[i][j] );
for(int j=i+1;j<rmax;j++){
for(int k=0;k<(int)G[j].size();k++)
rmax = max( rmax, G[j][k] );
}
res += (rmax - i)*3;
i = rmax-1;
}
cout << res << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
const int MOD = 1e9 + 7;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> imos(n + 10, 0);
for (int i = 0; i < m; i++)
{
int c, d;
cin >> c >> d;
if (c < d)
{
imos[c]++;
imos[d]--;
}
}
for (int i = 0; i < n; i++)
{
imos[i + 1] += imos[i];
}
int res = n + 1;
for (int i = 0; i < n; i++)
{
if (imos[i])
res += 2;
}
cout << res << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
using namespace std;
int main() {
int N, M; cin >> N >> M;
vector<pair<int,int>> V(M);
for(int i = 0; i < M; ++i) {
cin >> V[i].first >> V[i].second;
}
sort(V.begin(), V.end());
int ans = N - 1 + 2;
int index = 0;
while(index < M) {
// cerr << V[index].first << " -> ";
int l = V[index].first;
int r = V[index].second;
while(index + 1 < M && V[index + 1].first <= r) {
index++;
r = max(r, V[index].second);
}
ans += (r - l) * 2;
// cerr << r << endl;
index++;
}
cout << ans << endl;
}
|
#include<iostream>
using namespace std;
int n, q, a, b;
int x[100000], sum;
int main() {
cin >> n >> q;
for (int i = 0; i < q; i++) {
cin >> a >> b;
for (int j = a; j < b; j++) {
x[j] = 1;
}
}
for (int i = 0; i < n; i++) {
sum += 1 + x[i] * 2;
}
cout << sum + 1 << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <utility>
#include <cstdio>
#define C first
#define D second
#define MAXN 1100
using namespace std;
typedef pair<int,int> pii;
pii res[MAXN];
int add[MAXN];
bool cmp (const pii &a,const pii &b) { return a.C<b.C; }
int main(void) {
int n, m, c,d ;
while ( scanf("%d%d",&n,&m)==2 ) {
for (int i=0;i<m;++i) {
scanf ("%d%d",&c,&d);
res[i] = make_pair(c,d);
}
sort (res,res+m,cmp);
memset (add,0,sizeof(add));
for (int i=0;i<m;++i) {
add[res[i].C]++;
add[res[i].D]--;
}
int ans = 0, tmp = 0;
for (int i=0;i<=n;++i) {
tmp += add[i];
ans += (tmp > 0);
}
printf ("%d\n",ans*2+n+1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf=1e9;
const int64_t inf64=1e18;
const double eps=1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve(){
int n,m;
cin >> n >> m;
vector<bool> f(n+1);
rep(i,0,m){
int c,d;
cin >> c >> d;
rep(j,c,d) f[j]=true;
}
int ans=n+1;
rep(i,0,n+1) if(f[i]) ans+=2;
cout << ans << endl;
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1000];
int main()
{
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++){
int c, d;
scanf("%d %d", &c, &d);
--c, --d;
for (int i = c; i < d; i++){
a[i] = 1;
}
}
int res = 0;
for (int i = 0; i < n; i++){
if (a[i]) res += 3;
else res++;
}
printf("%d\n", ++res);
return 0;
}
|
#include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef pair<int ,int > P;
typedef long long ll;
void add(vector<P> &segs,int a,int b) {
if(b<a) swap(a,b);
bool f=true;
rep(i,segs.size()) {
if(!((b<segs[i].fr)||(segs[i].sc<a))) {
segs[i].fr=min(segs[i].fr,a);
segs[i].sc=max(segs[i].sc,b);
f=false;
}
}
if(f) segs.pb(P(a,b));
}
int N,m;
int main() {
vector<P> segs,in;
cin>>N>>m;
rep(i,m) {
int c,d;
cin>>c>>d;
in.pb(P(c,d));
}
sort(all(in));
ll ans=0;
rep(i,m) {
add(segs,in[i].fr,in[i].sc);
}
rep(i,segs.size()) {
//printf("%d %d\n",segs[i].fr,segs[i].sc);
ans+=(segs[i].sc-segs[i].fr)*2;
}
ans+=N+1;
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <cassert>
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 28;
int dp[510][1010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
while(cin >> N >> M) {
vector<P> r(M);
for(int i = 0; i < M; i++) {
cin >> r[i].second >> r[i].first;
}
sort(r.begin(), r.end());
fill((int*)begin(dp), (int*)end(dp), INF);
dp[0][N] = 0;
for(int i = 0; i < M; i++) {
int pos = r[i].first;
for(int j = 1; j <= N; j++) {
if(dp[i][j] == INF) continue;
int d = d = (i == 0) ? pos : abs(pos - r[i - 1].first);
// ??????
int ret = abs(pos - min(r[i].second, j));
dp[i + 1][N] = min(dp[i + 1][N], dp[i][j] + d + 2 * ret);
// ????????????
int nj = min(r[i].second, j);
dp[i + 1][nj] = min(dp[i + 1][nj], dp[i][j] + d);
}
}
int pos = (M == 0) ? 0 : r.back().first;
cout << dp[M][N] + (N + 1 - pos) << endl;
}
}
|
#include<iostream>
#include<algorithm>
using namespace std;
int n,t[1010];
int c[1010],d[1010];
int main()
{
int m;
cin>>n>>m;
for(int i=0;i<m;i++)
{
int l,r;cin>>l>>r;
t[l]++;t[r]--;
}
for(int i=1;i<=n;i++)t[i]+=t[i-1];
int ans=n+1;
for(int i=1;i<=n;i++)ans+=!!t[i]*2;
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, m;
int main() {
cin >> N >> m;
typedef pair< int, int > pii;
set< pii > interval;
for (int i=0; i<m; ++i) {
int c, d;
cin >> c >> d;
// left side
auto it = interval.lower_bound(pii(c, 0));
if (it != interval.begin()) {
--it;
if (c <= (*it).second) {
c = (*it).first;
d = max(d, (*it).second);
interval.erase(it);
}
}
// right side
it = interval.lower_bound(pii(c, 0));
if (it != interval.end()) {
if (c <= (*it).first && (*it).first <= d) {
d = max(d, (*it).second);
interval.erase(it);
}
}
interval.insert(pii(c, d));
}
int ans = N+1;
for (pii p : interval) {
int len = p.second - p.first;
ans += 2 * len;
}
cout << ans << endl;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <functional>
using namespace std;
#define Rep(b, e, i) for(int i = b; i <= e; i++)
#define Repr(e, b, i) for(int i = e; i >= b; i--)
#define rep(n, i) Rep(0, n-1, i)
#define repr(n, i) Repr(n-1, 0, i)
#define all(v) (v).begin(), (v).end()
#define pb(x) push_back(x)
#define uniq(x) (x).erase(unique(all(x)),(x).end())
typedef long long ll;
typedef pair<ll, ll> llP;
typedef pair<int, int> intP;
typedef std::priority_queue<int> IntPrioQueue; //Z->A
typedef std::priority_queue<int, std::vector<int>, std::greater<int> > IntReversePrioQueue; //A->Z
const int MAX = 1024;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1<<29;
const int MOD = 1000000007;
int step[MAX];
void solve(void){
int N, m;
cin >> N >> m;
rep(m, i) {
int a, b;
scanf("%d %d\n", &a, &b);
a--; b--;
step[a]++;
step[b]--;
}
rep(N, i) step[i+1] += step[i];
int dis = 0, ans = 0;
rep(N+1, n) {
if (step[n] > 0) dis++;
else {
ans += dis;
dis = 0;
}
}
ans = ans*2+1+N;
cout << ans << '\n';
}
int main(void){
solve();
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(void){
int n, m;
cin >> n >> m;
vector<int> s(n+2, 0);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
s[a]++;
s[b]--;
}
for (int i = 0; i < n+2; i++) s[i+1] += s[i];
int l = 0, ans = 0;
for (int i = 0; i < n+2; i++) {
if (l == 0 && s[i]) l = i;
if (l > 0 && !s[i]) {
ans += (i-l)*2;
l = 0;
}
}
cout << ans+n+1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
typedef pair<int,int> P;
int main() {
int n,m;
cin >> n >> m;
map<int,int> ma;
for(int i=0; i<m; i++) {
int x,y;
cin >> x >> y;
if(ma.count(y)) ma[y]=min(ma[y],x);
else ma[y]=x;
}
ma[0]=0;
vector<P> a;
for(map<int,int>::iterator it=ma.begin(); it!=ma.end(); it++) {
a.push_back(P(it->F,it->S));
}
m=a.size();
sort(a.begin(),a.end());
int d[m+1];
fill(d,d+m+1,100000);
d[0]=0;
for(int i=1; i<m; i++) {
int M=a[i].S;
for(int j=i-1; j>=0; j--) {
d[i]=min(d[i],d[j]+(a[i].F-a[j].F)+(a[i].F-M)*2);
M=min(M,a[j].S);
}
}
int ans=n-a[m-1].F+d[m-1]+1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define endl '\n'
#define ALL(a) (a).begin(),(a).end()
#define SZ(a) (int)((a).size())
typedef long long ll;
typedef pair<int,int> PI;
int main(int argc, char *argv[])
{
int n,m;
cin >> n >> m;
vector<PI> in;
rep(i,m){
int c,d;
cin >> c >> d;
in.pb(mp(c,d));
}
sort(ALL(in));
int ans = 0;
int cur = 0;
for(int i = 0; i < m; i){
int la = in[i].S;
int fi = in[i].F;
while(i < m && in[i].F <= la){
la = max(la,in[i].S);
++i;
}
ans += la - cur;
ans += la - fi;
cur = fi;
}
ans += n-cur+1;
cout << ans << endl;
}
|
#include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = { -1, 0, 1, 0 }; const int dy[] = { 0, 1, 0, -1 };
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vpii(m);
REP(i, m){
cin >> vpii[i].first >> vpii[i].second;
}
int ans = n+1;
int count = 0;
int beg=0;
FOR(i, 1, n + 1){
REP(j, m){
if (vpii[j].first == i){
count++;
if (count == 1)
beg = i;
}
if (vpii[j].second == i){
count--;
if (count == 0)
ans += (i - beg) * 2;
}
}
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
typedef pair<int,int> ii;
int N,m,par[1010];
int find(int x) {
if( x == par[x] ) return x;
return par[x] = find(par[x]);
}
void unit(int x,int y) {
x = find(x), y = find(y);
if( x != y ) par[x] = y;
}
int main(){
cin >> N >> m;
int cost = N+1,c,d;
rep(i,N+2) par[i] = i;
rep(i,m){
cin >> c >> d;
REP(j,c,d) unit(j,j+1);
}
map<int,int> group;
REP(i,1,N+1) ++group[find(i)];
for(map<int,int>::iterator it = group.begin(); it != group.end(); it++ ){
if( it->second <= 1 ) continue;
cost += ( it->second - 1 ) * 2;
}
cout << cost << endl;
return 0;
}
/********
* 1000 *
********/
/*********************
* go on to the next *
*********************/
/**************
* thank you! *
**************/
/**************
* help me... *
**************/
|
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
void solve()
{
cin.tie(0);
ios::sync_with_stdio(false);
bool needToMoveThreeTimes[1001];
memset(needToMoveThreeTimes, 0, sizeof(needToMoveThreeTimes));
int N, m;
cin >> N >> m;
for (int i = 0; i < m; ++i)
{
int c, d;
cin >> c >> d;
for (int j = c; j < d; ++j)
{
needToMoveThreeTimes[j] = true;
}
}
int ans = 0;
for (int i = 0; i < N; ++i)
{
if (needToMoveThreeTimes[i])
{
ans += 2;
}
}
cout << ans + N + 1 << endl;
}
int main()
{
solve();
return(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, m; cin >> N >> m;
vector<int> F(N+1, 1);
for(int i = 0; i < m; ++i) {
int c, d; cin >> c >> d;
for(int j = c; j < d; ++j) F[j] = 3;
}
cout << accumulate(F.begin(), F.end(), 0) << endl;
return 0;
}
|
// ACM-ICPCアジア地区予選2014 C. Shopping
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int N, m;
while(cin >> N >> m){
vector< pair<int,int> > p(m);
for(int i=0;i<m;i++) cin >> p[i].first >> p[i].second;
sort(p.begin(), p.end());
int idx = 0;
int res = N+1;
while(idx < m){
int b = p[idx].first, e = p[idx].second;
while(idx < m && p[idx].first < e){
e = max(e, p[idx].second);
++idx;
}
res += 2*(e-b);
}
cout << res << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,a,b,ans=1;
int c[1001];
int main(){
scanf("%d %d",&n,&m);
for(int i=0;i<m;i++){
scanf("%d %d",&a,&b);
c[a]++;
c[b]--;
}
for(int i=1;i<=n;i++){
c[i]+=c[i-1];
ans+=(c[i]?3:1);
}
printf("%d\n",ans);
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#define f first
#define s second
#define inf 1000000001
using namespace std;
int main()
{
int N,m,c,d;
vector<pair<int,int> > V;
cin>>N>>m;
for(int i=0;i<m;i++){
cin>>c>>d;
V.push_back(make_pair(c,d));
}
sort(V.begin(),V.end());
V.push_back(make_pair(inf,inf));
for(int i=0;i<V.size()-1;i++){
if(V[i+1].f<=V[i].s && V[i].s<=V[i+1].s){
V[i].s=V[i+1].s;
V.erase(V.begin()+i+1);
i--;
}
if(V[i].f<=V[i+1].f && V[i+1].s <=V[i].s){
V.erase(V.begin()+i+1);
i--;
}
}
/*
cout<<endl;
for(int i=0;i<V.size();i++)cout<<V[i].f<<" "<<V[i].s<<" "<<i<<endl;
*/
int ans=N+1;
for(int i=0;i<V.size();i++){
ans+=2*(V[i].s-V[i].f);
}
cout<<ans<<endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
#define push push_back
#define sz size()
#define s second
#define f first
using namespace std;
typedef pair<int,int> P;
int main(){
int N,m,c,d,ans=0;
vector<int> v2;
vector<P> v;
cin>>N>>m;
for(int i=0;i<m;i++) cin>>c>>d,v.push(make_pair(c,d));
sort(v.begin(),v.end());
if(v.sz!=0)
for(int i=0;i<v.sz-1;i++)
if(v[i+1].f<=v[i].s){
v[i].s=max(v[i].s,v[i+1].s);
v.erase(v.begin()+i+1);
i--;
}
for(int i=0;i<v.sz;i++) v2.push(v[i].s-v[i].f+1),ans+=v2[i];
ans=N+1-ans;
for(int i=0;i<v2.sz;i++) ans+=v2[i]*3-2;
cout<<ans<<endl;
return 0;
}
|
// 基本テンプレート
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
using namespace std;
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define repq(i,a,n) for(int (i)=(a); (i)<=(n); (i)++)
#define repr(i,a,n) for(int (i)=(a); (i)>=(n); (i)--)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;
#define fprintf(...) void(0)
int imos[1010];
signed main() {
int N, M; cin >> N >> M;
for(int i=0; i<M; i++) {
int l, r; cin >> l >> r;
imos[l]++;
imos[r]--;
}
for(int i=0; i<N+3; i++) {
imos[i+1] += imos[i];
}
int ans = N+1, last = -1;
for(int i=0; i<N+3; i++) {
if(imos[i+1] > 0 && imos[i] == 0) {
last = i+1;
}
if(imos[i+1] == 0 && imos[i] > 0) {
ans += (i+1 - last) * 2;
fprintf(stderr, "add: [%lld, %lld)\n", last, i+1);
}
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std;
int main(int argc, char *argv[])
{
int n, m;
cin >> n >> m;
vector<pair<int,int>> cds;
for(int i = 0; i < m; i++) {
int c, d;
cin >> c >> d;
cds.push_back(make_pair(c,d)); // visits c after d (> c)
}
sort(cds.begin(), cds.end());
// overlap -> rewind at onece
int len = n + 1;
int c = -1, d = -1;
for(int i = 0; i < m; i++) {
if(d < cds[i].first) { // do the previous overlap
len += 2 * (d - c);
c = cds[i].first;
d = cds[i].second;
} else { // overlapping
d = max(d, cds[i].second);
}
}
len += 2 * (d - c);
cout << len << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
vector<int> imos(n + 10,0);
for (int i = 0; i < m; i++) {
int c, d; cin >> c >> d;
if (c < d) {
imos[c]++;
imos[d]--;
}
}
for (int i = 0; i < n; i++) {
imos[i + 1] += imos[i];
}
int res = n + 1;
for (int i = 0; i < n; i++) {
if (imos[i]) res += 2;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, m;
cin >> N >> m;
vector<int> st(N + 2);
for (int i = 0, c, d; i < m; i++) {
cin >> c >> d;
st[c]++;
st[d]--;
}
int res = N + 1;
for (int i = 1; i <= N; i++) {
st[i] += st[i - 1];
if (st[i]) {
res += 2;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define llong long long
using namespace std;
signed main(){
int n,m; cin >> n >> m;
vector<pair<int, int> > b(m);
for(int i = 0; i < m; i++)cin >> b[i].first >> b[i].second;
sort(ALL(b));
vector<int> a(n+1,0);
for(auto e : b){
a[e.first] += 1;
a[e.second] += -1;
}
for(int i = 1; i < n+1; i++){
a[i] += a[i-1];
}
// for(auto e : a)cerr << e << " ";
// cerr << endl;
bool flag = false;
int cnt = 0;
int ans = n+1;
for(auto e : a){
if(flag && !e){
flag = false;
ans += 2*cnt;
cnt = 0;
// cerr << cnt << endl;
}
else if(e){
cnt++;
if(!flag)flag = true;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
using lint = long long;
using ldouble = long double;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> ps(m);
for (auto& p : ps) cin >> p.first >> p.second;
ps.emplace_back(n + 1, n + 1);
sort(ps.begin(), ps.end());
int ans = n + 1;
int l = 0, r = 0;
for (auto p : ps) {
if (r <= p.first) {
ans += (r - l) * 2;
l = r = p.first;
}
r = max(r, p.second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(long long i=0; i<(n); i++)
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(){
ll n,m; cin>>n>>m;
vector<ll> istwice(n+2, 0);
rep(i,m){
ll c,d; cin>>c>>d;
istwice[c]++;
istwice[d]--;
}
rep(i, n+1) istwice[i+1]+=istwice[i];
ll res=n+1;
rep(i, n+2){
if(istwice[i]>0) res+=2;
}
cout<<res<<endl;
return 0;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;
//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
vector<int>v(N + 1);
while (M--) {
cin >> L >> R;
v[L]++;
v[R]--;
}
for (int i = 1; i <= N; i++) {
v[i] += v[i - 1];
}
int ans = N + 1;
for (int i = 1; i <= N; i++) {
if (v[i])ans += 2;
}
cout << ans << endl;
}
|
#define _USE_MATH_DEFINES
#define rep(i, n) for(int i = 0; i < n; i++)
#define repx(i, a, n) for(int i = a; i < n; i++)
#define loop while(1)
#define lli long long int
#include <iostream>
#include <algorithm>
#include <cmath>
#include <numeric>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <utility>
#include <set>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> cnt(n + 1, 0);
int l, r;
rep (i, m) {
cin >> l >> r;
repx(j, l, r) cnt[j] += 1;
}
int ans = 0;
rep (i, n + 1) {
if (cnt[i] > 0) ans += 3;
else ans += 1;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int L,n;
cin>>L>>n;
vi in(L);
rep(i,n){
int a,b;
cin>>a>>b;
in[a-1]++;
in[b-1]--;
}
rep(i,L-1)in[i+1]+=in[i];
int out=L+1;
rep(i,L)if(in[i])out+=2;
cout<<out<<endl;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n, m;
std::cin >> n >> m;
vector<bool> visit(n + 1, false);
for (int i = 0; i < m; i++) {
int l, r;
std::cin >> l >> r;
for (int j = l; j < r; j++) {
visit[j] = true;
}
}
int ans = n + 1;
for (int i = 0; i < visit.size(); i++) {
ans += 2*visit[i];
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, m;
scanf("%d %d", &N, &m);
int s[1024] = {0};
for (int i = 0; i < m; i++){
int a, b;
scanf("%d %d", &a, &b);
s[a]++;
s[b]--;
}
int ans = 0;
for (int i = 0; i <= N;){
if (s[i] == 0){
ans++;
i++;
}
else {
int rui = 0;
int tmp = 0;
while (rui + s[i] != 0){
rui += s[i];
tmp++;
i++;
}
i++;
ans += 3 * tmp + 1;
}
}
printf("%d\n", ans);
return (0);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.