text stringlengths 49 983k |
|---|
// 12:17 - 13:14
#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cassert>
#include<climits>
#include<map>
#include<queue>
#include<set>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX_SP 15
#define MAX_LEN 60
u... |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8;
const int dx[] = { 1, 0, -1, 0 };
const int dy[] = { 0, 1, 0, -1 };
const int var = 4;
string D = "DRUL";
struct node {
node *fail;
vector<node*> next;
vector<int> ok;
node() : fail(nullptr), next(var, nullptr) {}
};
class Aho_Corasick {
stat... |
#include <vector>
#include <string>
#include <memory>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;
#define rep(i,n) for(int i=0,i##_len=n;i<i##_len;i++)
#define all(x) begin(x),end(x)
#define lim(x,r,l) (r<=x&&x<l)
typedef long long ll;
typedef long double ld;
struct PMA {
... |
#include "bits/stdc++.h"
#define REP(i, n) for (int i = 0; i < n; ++i)
// https://onlinejudge.u-aizu.ac.jp/status/users/EtoNagisa/submissions/1/2212/judge/3966278/C++14
using namespace std;
#include "bits/stdc++.h"
struct lower_alphabet {
static constexpr std::size_t char_size = 26;
static constexpr char min_cha... |
#include <queue>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const string ds = "RDLU";
const vector<int> dx = { 0, 1, 0, -1 };
const vector<int> dy = { 1, 0, -1, 0 };
struct state {
int x, y, ban, len;
};
int dist[53][53][13][13];
int main() {
i... |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#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>
#in... |
#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;... |
#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<cstring>
using namespace std;
class PMA{//Aho-Corasick
int id;
bool match;
PMA *failure;
PMA *next[256];
public:
PMA(int id=0):id(id),match(false),failure(0){
memset(next,0,sizeof(next));
}
~PMA(){
for(int i=0;i<256;i++){
if(n... |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cstring>
using namespace std;
struct Entry {
int x, y, state, step;
};
int dx[] = { -1, 1, 0, 0 };
int dy[] = { 0, 0, -1, 1 };
const char *LABELS[] = { "L", "R", "U", "D" };
class Match... |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <cstdio>
#include <cstring>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define DEB 0
#define all(x) x.begin(), x.end()
#define mp make_pair
#define pb push_back
... |
#include<stdio.h>
#include<string>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
char str[60][60];
char in[60];
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
char dc[7]="DRUL";
int bfs[60][60][110];
string val[110];
int ng[110];
int main(){
int a,b;
while(scanf("%d%d",&a,&b),a){
for(int i=0;i<a... |
#include <bits/stdc++.h>
using namespace std;
const int vy[] = {0, 1, 0, -1}, vx[] = {1, 0, -1, 0};
const string temp = "RDLU";
const int mask = (1 << 18) - 1;
int H, W, P, sx, sy;
string S[50], V[10];
int solve()
{
queue< tuple< int, int, int, int > > que;
int min_cost[50][50][10][10];
memset(min_cost, -1,... |
#include <bits/stdc++.h>
#define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
#define pr(...) cerr<< GET_MACRO(__VA_ARGS__,pr8,pr7,pr6,pr5,pr4,pr3,pr2,pr1)(__VA_ARGS__) <<endl
#define pr1(a) (#a)<<"="<<(a)<<" "
#define pr2(a,b) pr1(a)<<pr1(b)
#define pr3(a,b,c) pr1(a)<<pr2(b,c)
#define pr4(a,b,c,d) pr1(a)<<pr3(b,c,... |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
using namespace std;
typedef pair<int, int> P;
typedef pair<P, int> P2;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#defin... |
#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;... |
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include... |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
using namespace std;
typedef pair<int, int> P;
int n, m, p, K, ans;
const char UDLR[4] = {'U', 'D', 'L', 'R'};
const int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
char map[52][52], tmp[15];
string patterns[15];
... |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include... |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#define V(x, y, z) ((x) * 1000000 + (y) * 1000 + (z))
#define inf 1000000000
using namespace std;
int W, H;
char map[55][55];
int P;
string S[15];
int sx, sy, gx, gy;
vector<string> vec;
int Next[105][4];
bool ng[105][4];
c... |
#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<cstring>
using namespace std;
class PMA{//Aho-Corasick
int id;
bool match;
PMA *failure;
PMA *next[256];
public:
PMA(int id=0):id(id),match(false),failure(0){
memset(next,0,sizeof(next));
}
~PMA(){
for(int i=0;i<256;i++){
if(n... |
#include<iostream>
#include<string>
#include<queue>
#include<vector>
#include<tuple>
using namespace std;
int H, W, K, x[60][60], dist[60][60][200], sx, sy, gx, gy, dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };
string S[10], dir = "DRUL";
vector<tuple<string, int, int>>vec;
vector<tuple<int, int, int>> X[60][60][200];
ve... |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8;
const int dx[] = { 1, 0, -1, 0 };
const int dy[] = { 0, 1, 0, -1 };
string D = "DRUL";
// Aho-Corasick
const int var = 4;
int trans(char c) {
switch (c)
{
case 'R': return 0;
case 'D': return 1;
case 'L': return 2;
case 'U': return 3;
defaul... |
#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;
class PMA
{
... |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)(n);... |
#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;... |
#include <array>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
constexpr int ALPHA = 4;
constexpr int MAX_V = 10000;
const int BASE = 'a';
struct trie {
int v;
int failure;
bool accept;
array<int, ALPHA> next;
explicit tr... |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define CMAX 4
#define OFFSET 0
struct Node { int nxt[CMAX + 1]; int exist; vector<int> accept;
Node() : exist(0){ memset(nxt, -1, sizeof(nxt)); }};
struct Trie {
vector<Node> nodes; int root;
Trie() : root(0){ nodes.push_back(N... |
#include <bits/stdc++.h>
using namespace std;
const int var = 4;
const int pmax = 1e4;
int trans(char c) {
switch (c)
{
case 'R': return 0;
case 'D': return 1;
case 'L': return 2;
case 'U': return 3;
default: assert(false);
}
}
struct ac_node {
ac_node *fail;
ac_node *next[var];
int ok;
ac_node() : fail(... |
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <string>
#include <set>
#include <map>
using namespace std;
struct State {
int x, y, e;
};
const int INF = (1<<28);
const int MAXH = 51;
const int MAXW = 51;
const int MAXP = 11;
const string dc[] = {"R","D","L","U"};
const int dx... |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
int NODE_NUM;
struct Node{
map<char, Node*> next;
Node* fail;
vector<int> match;
int node_id;
Node() : fail(NULL) {
node_id = NODE_NUM++;
}
~Node(){ for(auto p : next) if(p.second) delete... |
#include <string>
#include <vector>
#include <queue>
#include <cassert>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
class AhoCorasick{
static const int ASIZE = 256;
struct node_t {
int ID;
node_t *failure;
node_t *output;
node_t *next[ASIZE];
std::vec... |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <map>
#include <fstream>
using namespace std;
class Sit{
public:
int x,y;
int cur;
};
/*
* RXgN^É«¶ñðnµÄtry treeðì¬
* »ÌãÍeíTõÖðÄÑoµÄAØÉεÄTõð©... |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cas... |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <cassert>
using na... |
// 12:17 - 13:14
#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cassert>
#include<climits>
#include<map>
#include<queue>
#include<set>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX_SP 15
#define MAX_LEN 60
usi... |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct FastIO{
FastIO(){
cin.tie(0);
ios::sync_with_stdio(0);
}
}fastio_beet;
te... |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
using namespace std;
int n,m;
string maze[55];
int fg[110][5],ac[110];
char dir[5]={' ','U','R','D','L'};
int di[5]={0,-1,0,1,0};
int dj[5]={0,0,1,0,-1};
int build(vector<string> pattern){
memset(fg,-1,sizeof(fg));
memset(ac,0,sizeof(ac));
int root=0... |
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include... |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using... |
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
char str[60][60];
int h[]={2,3,3,3,3,3,3,3,3,3,3};
int w[]={5,4,4,4,4,4,4,4,4,4,4};
char tkz[11][6][6]={
{
"DLU..",
"..FRB"
},
{
"U...",
"FRBL",
"D..."
},
{
"U...",
"FRBL",
".D.."
},
{
"U...",
"FRBL",
"..D."
},
{
"U...",
"FRBL",
"...D"
},
{
".U... |
#include <bits/stdc++.h>
using namespace std;
// 0: top, 1: front, 2:right, 3:back, 4:left, 5:bottom
const vector<vector<string>> dice_map = {
{"0...",
"1234",
"5..."},
{"0...",
"1234",
".5.."},
{"0...",
"1234",
"..5."},
{"0...",
"1234",
"...5"},
{".0..",
... |
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0... |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pa... |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct LOC{
LOC(int arg_row,int arg_col){
row = arg_row;
col = arg_col;
}
int row,col;
};
//0:... |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct Dice{
int s[6];
void roll(char c){
//the view from above
// N
//W E
... |
#include<stdio.h>
#include<algorithm>
using namespace std;
int p[500];
int q[250][500];
int r[250][500];
int ret[500];
int s[500];
int t[250][500];
int u[500];
int v[250][500];
int w[250][500];
int ABS(int a){return max(a,-a);}
int LIM=240;
int main(){
int a;
scanf("%d",&a);
for(int i=0;i<a;i++)p[i]=i;
for(int i=0;... |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend... |
//http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1180
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
#include <iomanip>
#include <queue>
using ll = long long;
using namespace std;
int const MOD = 1e9 + 7;
int GCD(int x, int y)
{
... |
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define debug(x) cout << "debug " << x << endl;
const int INF = 100000000;
using namespace std;
//?????§??¬?´???°
int gcd(int x, int y) {
int r;
if(x ... |
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
... |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
long long int gcd(long long int l, long long int r) {
if (l > r)return gcd(r, l);
else {
if (r%l) {
return gcd(l, r%l);
}
else {
return l;
}
}
}
map<long long int, int>soinnsuu(... |
#include <iostream>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int p, q;
cin >> p >> q;
int g = gcd(p, q);
p /= g;
q /= g;
int ans = 1;
for (int i = 2; i * i <= q; i++) {
if (q % i != 0) continue;
while (q % i == 0) { q /= i; }
ans *= i;
... |
#include <iostream>
using namespace std;
int gcd(int x, int y) {
return y == 0 ? x : gcd(y, x%y);
}
int P, Q;
int main() {
cin >> P >> Q;
int v = Q / gcd(P, Q);
for (int d = 2; d*d <= v; ++d) {
if (v % d == 0) {
while ((v/d)%d == 0) { v /= d; }
}
}
cout << max(2, v... |
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 1000000000
int gcd(int a, int b)
{
if (a < b)
return gcd(b, a);
else if (a % b)
return gcd(b, a % b);
else
return b;
}
int main()
{
int p, q;
cin >> p >> q;
q /= gcd(p, q);
map<int, int> res;
for (int i =... |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<int ,P> P3;
typedef pair<P ,P> PP;
const ll MOD = ll(1e9+7);
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-6;
const int... |
#include <iostream>
#include <vector>
using namespace std;
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a%b);
}
int main() {
vector<int> prime;
vector<bool> is_prime(1e5, true);
is_prime[0] = is_prime[1] = false;
for(int i=2; i<1e5; ++i) {
if(is_prime[i]) {
prime.push_bac... |
#include <iostream>
using namespace std;
int gcd(int u, int v){
while(v!=0){
int r = u%v;
u = v;
v = r;
}
return u;
}
int main(){
int p,q;
cin >> p >> q;
q /= gcd(p,q);
int ans=1;
int rq=q;
for(int i=2; i*i<=q; i++){
if(rq%i==0){
ans*=i;
}
while(rq%i==0){
rq/=i;
}
}
ans *= rq;
cout <... |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include ... |
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n... |
#include<iostream>
#include<algorithm>
#include<string>
#include<cstdlib>
#include<map>
#include<iomanip>
#include<sstream>
#include<vector>
#include<stack>
#include<math.h>
#include<queue>
#include<complex>
#include<random>
#include<ctime>
#include<set>
using namespace std;
const long long int mod=1000000007;
const ... |
#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>
#include<assert.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loo... |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (int)(k); i < (int)(n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,... |
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include ... |
#include <iostream>
#include <vector>
#include <math.h>
using namespace std;
int gcd(int a, int b){
int temp1 = a, temp2 = b;
if (temp1 < temp2){
int temp;
temp = temp1;
temp1 = temp2;
temp2 = temp;
}
if(temp2 == 0) return temp1;
return gcd(temp2, temp1%temp2);
}
int main(){
int p, q, m;
cin >> p >> q;... |
/* main code starts from line 155. */
/* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
// container library
#include <array>
#include <bitset>
#include <map>
#... |
#include<iostream>
using namespace std;
int gcd(int a, int b){
return b == 0 ? a : gcd(b, a%b);
}
int main(){
int p, q;
cin >> p >> q;
int g = gcd(p, q);
p /= g, q /= g;
int ans = 1;
for(int i = 2; i*i <= q; i++){
if(q % i == 0){
ans *= i;
while(q % i ... |
#include<stdio.h>
#include<math.h>
int gcd(int a,int b){
if(a < b){
int c = a;
a = b;
b = c;
}
if(a % b == 0)
return b;
return gcd(b,a % b);
}
bool judgeprime(int n){
if(n == 1 || n % 2 == 0)
return false;
int i,j;
j = (int)sqrt(n) + 1;
bool k =... |
#include<cstdio>
#include<algorithm>
#include<cmath>
int era[100000];
using namespace std;
int main(void)
{
int p,q,i,j,kou,x,a,b,suu,flg;
scanf("%d %d",&p,&q);
a=q; b=p;
while(1) {
x=a%b;
if(x==0) break;
a=b;
b=x;
}
for(i=2;i<=100000;i++) era[i]=1;
for(i=2;i*i<=100000;i++) {
if(era[i]==1) {
for(j=2... |
#include <iostream>
#define llint long long
using namespace std;
llint p, q;
bool prime[100005];
llint gcd(llint a, llint b)
{
if(b == 0) return a;
return gcd(b, a%b);
}
int main(void)
{
cin >> p >> q;
llint g = gcd(p, q);
p /= g, q /= g;
for(int i = 2; i < 1005; i++){
if(prime[i]) continue;
for(int j... |
#define _CRT_SECURE_NO_WARNINGS
#pragma comment (linker, "/STACK:526000000")
#include "bits/stdc++.h"
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144*2LL
#define pb push_back
#define ... |
#include <iostream>
#include <map>
#include <cmath>
using namespace std;
int euclid(int x, int y){
int t;
while (x % y){
x %= y;
t = x;
x = y;
y = t;
}
return y;
}
int main(){
int p, q, n, m, t = 2, ans = 1;
cin >> p >> q;
n = q / euclid(p, q);
m = n;
map<int, int> f;
while (n > 1 && t < sqrt(m) + 1)... |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#define CH(N,A,B) (A<=N&&N<B)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define RREP(i,a,b) for(int i=(b-1);a<=i;i--)
using namespace std;
i... |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
using std::cin;
using std::cout;
using std::endl;
using std::setprecis... |
#include <iostream>
using namespace std;
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
int main() {
long long p, q; cin >> p >> q;
long long d = GCD(p, q);
q /= d;
for (long long v = 2; v*v <= q; ++v) {
while (q % (v*v)== 0) q /= v;
}
... |
#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 <func... |
#include<iostream>
using namespace std;
int gcd(int x, int y) {
return y == 0 ? x : gcd(y, x%y);
}
int main() {
int p, q, r=1;
cin >> p >> q;
q = q / gcd(q, p);
for (int i = 2; i*i <= q; ++i) {
if (q%i == 0) {
r *= i;
while (q%i == 0) q /= i;
}
}
cout << r * q << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <cmath>
#define REP(i,a,b) for(int i=int(a);i<int(b);i++)
using namespace std;
typedef long long int lli;
lli gcd(lli a, lli b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main () {
lli p, q;
cin >> p >> q;
... |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<functional>
#include<map>
using namespace std;
int gcd(int a, int b) {
if (b == 0)return a;
return gcd(b, a%b);
}
int main() {
int a, b; cin >> a >> b;
b = b / gcd(a, b); a = b;
int c =... |
#include "bits/stdc++.h"
#define REP(i, n, N) for(ll i=(n); i<(N); i++)
#define RREP(i, n, N) for(ll i=(N-1); i>=(n); i--)
#define LREP(lst,itr) for(auto itr = lst.begin(); itr != lst.end(); ++itr)
#define CK(n, a, b) ((a)<=(n)&&(n)<(b))
#define ALL(v) (v).begin(),(v).end()
#define MCP(a, b) memcpy(b,a,sizeof(b))
#def... |
#include <iostream>
#include <vector>
using namespace std;
int main(){
int p,q,use;
int so[40000]={0};
cin>>p>>q;
use=q;
int a;
while(q%p!=0){
a=q%p;
q=p;
p=a;
}
use/=p;
q=use;
vector <int> sonaka;
for(int i=2;i<40000;i++) if(so[i]==0){
sonaka.push_back(i);
for(int j=i*2;... |
#include <bits/stdc++.h>
using namespace std;
// calculate |gcd|.
// if ether num is 0, return 0
long long GCD(long long left, long long right) {
if(left == 0 || right == 0) return 0;
if(left < 0) left *= -1;
if(right < 0) right *= -1;
if(left < right) swap(left, right);
long long nextnum, ansgcd = -1;
wh... |
#include <iostream>
#include <vector>
#define REP(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
using namespace std;
typedef long long ll;
int P, Q;
bool p[100000];
vector<int> v;
int gcd(int a, int b) {
if(b == 0) return a;
return gcd(b, a % b);
}
bool prime(int n) {
REP(i, 0, v.size()) if(n % v[i] == 0... |
#include <iostream>
#include <map>
#include <cmath>
using namespace std;
int euclid(int x, int y){
int t;
while (x % y){
x %= y;
t = x;
x = y;
y = t;
}
return y;
}
int main(){
int p, q, n, m, t = 2, ans = 1;
cin >> p >> q;
n = q / euclid(p, q);
m = n;
map<int, int> f;
while (n > 1 && t < sqrt(m) + 1)... |
#include <iostream>
using namespace std;
// a>b
int gcd(int a, int b)
{
if (b == 0) return a;
return gcd(b, a%b);
}
int main()
{
int p, q;
cin >> p >> q;
q /= gcd(p, q);
int ans = 1;
for (int i = 2; i*i <= q; i++) {
if (q%i == 0) {
ans *= i;
while (q%i == 0) q /= i;
}
}
cout << ans*q << endl;;
... |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int gcd(int a, int b) { if (!b)return a; return gcd(b, a%b); }
int main() {
int p, q; cin >> p >> q;
q /= gcd(p, q);
map<int, int>m;
for (int i = 2; i*i <= q; i++) {
while (q%i == 0) {
m[i]++; q /= i;
}
}
if (q != 1)m[q] = 1... |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A,... |
#include <stdio.h>
#include <math.h>
int gcd(int a, int b) {
int t;
while(b) {
t = a % b;
a = b;
b = t;
}
return a;
}
int main(void){
int p, q, i, j, ans = 1, bef = 0;
scanf("%d%d", &p, &q);
q /= gcd(p, q);
for(i = 2; i <= sqrt(q) + 1;) {
if(!(q % i)) {
if(bef != i) ans *= i, bef... |
#include <iostream>
#include <vector>
using namespace std;
int main(){
int p,q,use;
int so[40000]={0};
cin>>p>>q;
use=q;
int a;
while(q%p){
a=q%p;
q=p;
p=a;
}
use/=p;
vector <int> sonaka;
for(int i=2;i<40000;i++) if(!so[i]){
sonaka.push_back(i);
for(int j=i*2;j<40000;j+=i) ... |
#include<bits/stdc++.h>
using namespace std;
#define N 1000000000
typedef long long int ll;
ll gcd(ll a,ll b){
if(b==0)return a;
else return gcd(b,a%b);
}
queue<ll> q;
vector<bool> prime(N+1,true);
void make(ll M){
prime[0]=prime[1]=false;
ll i;
for( i=2;i*i<=M+1;i++){
if(prime[i]){
ll j=2;
q.push(i);
while(i... |
#include <bits/stdc++.h>
using namespace std;
using vi=vector<int>;
using vvi=vector<vi>;
using vs=vector<string>;
using msi=map<string,int>;
using mii=map<int,int>;
using pii=pair<int,int>;
using vlai=valarray<int>;
using ll=long long;
#define rep(i,n) for(int i=0;i<n;i++)
#define range(i,s,n) for(int i=s;i<n;i++)
#... |
#include<cstdio>
#include<cstring>
long long int gcd(long long int p, long long int q) {
if(!q) return p;
if(q>p) return gcd(q, p);
return gcd(q, p%q);
}
int main(void) {
long long int p,q;
scanf("%lld%lld",&p,&q);
long long int g = gcd(p,q);
p/=g; q/=g;
long long int b=1;
for(lon... |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
ll P, Q;
cin >> P >> Q;
ll G = gcd(P, Q);
Q /= G;
ll ans = 1;
ll QQ = Q;
for(ll i = 2; i * i <= Q; i++) {
ll cnt = 0;
while(QQ % i == 0) {
... |
#include<iostream>
#include <list>
#include<stack>
#include<queue>
#include <vector>
#include <set>
#include<algorithm>
#include<math.h>
#include<stdlib.h>
#include<string>
#include <functional>
#include<fstream>
#define FOR(k,m,n) for(int (k)=(m);(k)<(n);(k)++)
#define REP(i,n) FOR((i),0,(n))
#define LL long long
#de... |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,P> PP;
const long long int MOD = 1000000007;
const int INF = 1000000000;
int p, q;
int main(){
cin >> p >> q;
int pp = p, qq = q;
while(qq){
pp %= ... |
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c... |
#include <iostream>
#include <cmath>
using std::cin;
using std::cout;
using std::endl;
int gcd(int n, int m) {
if ( n%m == 0 ) {
return m;
}
else {
return gcd(m,n%m);
}
}
int main(void) {
int p,q;
cin >> p >> q;
int n = q;
int m = p;
int l = gcd(n,m);
while ( l != 1 ) {
n = n/l;
m = m/l;
l = gcd... |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <sstream>
using namespace std;
long long int LCM(long long int a, long long int b){
long long int dummy1, dummy2, dummy;
dummy1 = max(a, b);
dummy2 = min(a, b);
while(true){
dummy = dummy1 % d... |
#include"bits/stdc++.h"
using namespace std;
using ll = int64_t;
ll gcd(ll a, ll b) {
return (b == 0 ? a : gcd(b, a % b));
}
bool isPrime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
ll p, q;
cin >> p >>... |
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define each(a, b) for(auto (a): (b))
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
#define pb push_back
#define show(x) cout <<#x<<" = "<<(x... |
#include <bits/stdc++.h>
using namespace std;
int Prime[100000]={};
void pr(){
Prime[0]=2;
int tmp=1,num=1;
while(num<100000){
num+=2;
int flag=0;
for(int i=3;i<=sqrt(num);i+=2)
if(num%i==0) flag++;
if(flag==0) Prime[tmp++]=num;
}
}
int gcd(int x,int y){
return y?gcd(y,x%y):x;
}
int... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.