The 2024 Hunan Multi-School Programming Training Contest, Round 1

写在前面
A
B
C
I
K
L
F
G
D
写在最后

写在前面

以下按个人向难度排序。

很基础的一套题，感觉以后结训比赛可以搬几道。

Just a Way 首战被吊打呃呃

A

模拟即可。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
//=============================================================
//=============================================================
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  LL h, k, v, s, ans = 0;
  std::cin >> h >> k >> v >> s;
  while (h > 0) {
    v += s;
    v -= std::max(1ll, v / 10ll);
 
    if (v >= k) ++ h;
    else if (v > 0) -- h;
    else v = 0, h = 0;
 
    if (h <= 0) v = 0;
 
    ans += v;
 
    if (s > 0) -- s;
  }
 
  std::cout << ans << "\n";
  return 0;
}

B

发现有限制 $h - l\le 1000$ ，则直接暴力枚举每一段的长度并枚举每一段检查的复杂度是 $O((h - l)\times n)$ 级别的，暴力即可。

 #include<bits/stdc++.h>
using namespace std;
#define int long long
int n,l,h;
const int N=3e4+5;
int a[N],b[N];
int sum(int li,int ri){
	return b[ri]-b[li-1];
}
int f[N][2];//0 min 1 max 
signed main(){
	std::cin>>n>>l>>h;
	for(int i=1;i<=n;++i){
		cin>>a[i];
		b[i]=b[i-1]+a[i];
	}
	int minn=n*n*n,maxx=0;
	for(int i=l;i<=h;++i){
		for(int k=1;k<=i;++k){
			int tmp=sum(1,k);
			int num=0;
			if(tmp>0) num++;
			for(int j=k+1;j<=n;j+=i){
				int r=j+i-1;
				r=min(r,n);
				tmp=sum(j,r);
				if(tmp>0) ++num;
			}
			minn=min(minn,num);
			maxx=max(maxx,num);	
		}
	}
	cout<<minn<<' '<<maxx<<endl;
	return 0;
}

C

一个显然的想法是对于一个很大块的图形，应当按照有内到外进行覆盖。

反向地考虑，则与空白直接相连的区域 $S_1$ 可以最后覆盖，不与空白相连但与 $S_1$ 直接相连的区域可以在倒数第二步覆盖……

于是枚举所有空白位置开始进行 BFS 即可求得图形的最内层至少是倒数第几步覆盖的——即最少操作次数。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
#define pii std::pair<int,int>
#define mp std::make_pair
const int kN = 1010;
const int ex[4] = {0, 0, 1, -1};
const int ey[4] = {1, -1, 0, 0};
//=============================================================
int n, m, val[kN][kN];
bool vis[kN][kN];
std::string map[kN];
//=============================================================
void BFS() {
  std::queue <pii> q;
 
  for (int i = 0; i < n; ++ i) {
    for (int j = 0; j < m; ++ j) {
      val[i][j] = kN;
      if (map[i][j] == '-') {
        val[i][j] = 0;
        q.push(mp(i, j));
      }
    }
  }
  for (int i = 0; i < n; ++ i) {
    for (int j = 0; j < m; ++ j) {
      if (map[i][j] == '-') continue;
      if (i == 0 || j == 0 || i == n - 1 || j == m - 1) {
        val[i][j] = 1;
        q.push(mp(i, j));
      }
    }
  }
  
 
  while (!q.empty()) {
    pii p = q.front(); q.pop();
    int x = p.first, y = p.second;
    if (vis[x][y]) continue;
    vis[x][y] = 1;
 
    for (int i = 0; i < 4; ++ i) {
      int nx = x + ex[i], ny = y + ey[i];
      if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
      val[nx][ny] = std::min(val[nx][ny], val[x][y] + 1);
      q.push(mp(nx, ny));
    }
  }
}
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  std::cin >> n >> m;
  for (int i = 0; i < n; ++ i) std::cin >> map[i];
  BFS();
 
  int ans = 1;
  for (int i = 0; i < n; ++ i) {
    for (int j = 0; j < m; ++ j) {
      ans = std::max(ans, val[i][j]);
    }
  }
  std::cout << ans << "\n";
  return 0;
}

I

爆搜题。

若给定的 $n$ 个单词中出现超过 18 种字符则无解，否则补齐 18 种字符。

然后直接爆搜枚举三个字符集合并检查即可，集合总数为：

(\binom{18}{6}) \times (\binom{12}{6}) \approx 2 \times 10^{7}

${{18}\choose {6}}\times {{12}\choose{6}} \approx 2\times 10^7$

加上剪枝之后跑得飞快。

 #include <bits/stdc++.h>
using namespace std;
int n, A[10], B[10], o; 
char s[1010][5], S[30]; 
bool vis[300], vis2[300], p[300];
void dfs2(int k) {
    if (k == 7) {
        
        for (int i = 1; i <= n; i++) {
            int cnt = (int)vis2[s[i][0]] + (int)vis2[s[i][1]] + (int)vis2[s[i][2]];
            if (cnt != 1) return ;
        }
        for (int i = 1; i <= 6; i++) cout << S[A[i]]; cout << " ";
        for (int i = 1; i <= 6; i++) cout << S[B[i]]; cout << " ";
        for (int i = 1; i <= o; i++) if (!vis[S[i]] && !vis2[S[i]]) cout << S[i]; cout << " ";
        exit(0);
    }
    for (int i = B[k - 1] + 1; i <= o; i++) 
        if (!vis[S[i]]) {
            B[k] = i;
            vis2[S[i]] = true;
            dfs2(k + 1);
            vis2[S[i]] = false;
        }
}
void dfs(int k) {
    if (k == 7) {
        
        for (int i = 1; i <= n; i++) {
            int cnt = (int)vis[s[i][0]] + (int)vis[s[i][1]] + (int)vis[s[i][2]];
            if (cnt != 1) return ;
        }
        dfs2(1);
        return ;
    }
    for (int i = A[k - 1] + 1; i <= o; i++) 
    {
        A[k] = i;
        vis[S[i]] = true;
        dfs(k + 1);
        vis[S[i]] = false;
    }
}
 
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
        if (s[i][0] == s[i][1] || s[i][0] == s[i][2] || s[i][1] == s[i][2]) {
            cout << "0\n";
            return 0;
        }
        p[s[i][0]] = p[s[i][1]] = p[s[i][2]] = true;
    }
    o = 0;
    for (char c = 'a'; c <= 'z'; c++) {
        if (p[c]) S[++o] = c;
    }
    if (o > 18) {
        cout << "0\n";
        return 0;
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        if (!p[c] && o < 18) S[++o] = c;
    }
    dfs(1);
    cout << "0\n";
    return 0;
}

K

妈的这次题面怎么都这么难读、、、

因为人是按照 DFS 序寻路，相当于走到最左侧的叶子，则删点也一定是按照 DFS 序删的，这样每删去一个点影响最小，相当于只剪去了最左侧的叶子。

当出现第一个无法到达目标的人时即结束，于是考虑进行 DFS 枚举节点并在此过程中维护删到该节点时可以处理到第几个人的目标，仅需检查询问目标位置是否在根到该节点的链上即可，当出现某人的目标已被删掉时说明结束。

 #include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=2e5+5;
int n,m,tot,head[N];
int d[N],now;
struct node{
	int to,nxt;
}e[N<<1];
void add(int u,int v){
	e[++tot].to=v,e[tot].nxt=head[u],head[u]=tot;
}
bool ok[N];
void dfs(int u){
	ok[u]=1; 
//	cout<<u<<endl;
//	for(int i=1;i<=n;++i){
//		cout<<ok[i]<<' ';
//	} cout<<endl;
	while(now<m&&ok[d[now+1]]){
		++now;
	}
	vector<int>so;
	for(int i=head[u];i;i=e[i].nxt){
		so.push_back(e[i].to);
	}
	sort(so.begin(),so.end());
	for(auto v:so){
		dfs(v);
	}
	ok[u]=0;
}
signed main(){
	cin>>n>>m;
	for(int i=1,u,v;i<n;++i){
		cin>>u>>v;
		add(u,v);
	}
	now=0;
	for(int i=1;i<=m;++i){
		cin>>d[i];
	}
	dfs(1);
	cout<<now<<endl;
	return 0;
}

L

DP。

场上大神 dztle 用大力区间 DP 草过去了，然而 std 只是线性 DP。

懒得补了，略。

Code by dztle：

  
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=105;
char s[N];
int a[N],sum;
int ans=N*N;
int f[N][N][2];
void doit(){
	memset(f,0x3f,sizeof(f));
	for(int i=1;i<=sum;++i){
		if(a[i]==0) f[i][i][0]=0;
		else f[i][i][1]=0;
		
	}
	for(int i=1;i<sum;++i){
		if(a[i]==0&&a[i+1]==0) f[i][i+1][0]=0,f[i][i+1][1]=1;
		if(a[i]==0&&a[i+1]==1) f[i][i+1][0]=1,f[i][i+1][1]=2;
		if(a[i]==1&&a[i+1]==0) f[i][i+1][0]=1,f[i][i+1][1]=2;
		if(a[i]==1&&a[i+1]==1) f[i][i+1][0]=1,f[i][i+1][1]=0;
	}
	for(int L=3;L<=sum;++L){
		for(int i=1;i<=sum;++i){
			int r=i+L-1;
			if(r>sum) break;
			for(int mid=i;mid<r;++mid){
				for(int ty=0;ty<=1;++ty){
					f[i][r][ty]=min(f[i][r][ty],f[i][mid][ty]+f[mid+1][r][ty]);
				}
			}
			if(L%2==0){
				f[i][r][0]=min(f[i][r][0],f[i][r][1]+(L/2));
				f[i][r][1]=min(f[i][r][1],f[i][r][0]+(L/2));	
			}else{
				f[i][r][0]=min(f[i][r][0],f[i][r][1]+(L/2)+1);
				f[i][r][1]=min(f[i][r][1],f[i][r][0]+(L/2)+2);
			}
			if((r-i)%2==0) f[i][r][1]=min(f[i+2][r][0]+1+(r-i)/2,f[i][r][1]);
			else f[i][r][1]=min(f[i+2][r][0]+1+(r-i)/2+2,f[i][r][1]);
			if((r-i)%2==0) f[i][r][1]=min(f[i][r-2][0]+1+(r-i)/2,f[i][r][1]);
			else f[i][r][1]=min(f[i][r-2][0]+1+(r-i)/2+2,f[i][r][1]);
		}
	}
	ans=min(ans,f[1][sum][1]);
}
signed main(){
	scanf("%s",s+1);
	int len=strlen(s+1);
	if(len%2==0){
		sum=len/2;
		for(int i=1;i<=sum;++i){
			if(s[i]==s[len-i+1]) a[i]=1;
			else a[i]=0;
		}
		++sum;
		a[sum]=1;
		doit();
		a[sum]=0;
		doit();
	}else{
		sum=len/2; ++sum;
		for(int i=1;i<sum;++i){
			if(s[i]==s[len-i+1]) a[i]=1;
			else a[i]=0;
		}
		a[sum]=1;
		doit();
		a[sum]=0;
		doit();
	}
	cout<<ans;
	return 0;
}
/*
abbaaaabb
*/

F

DP。

发现每次检查之后相当于抛弃了之前所有天数的贡献，考虑 DP。

记 $f_{i, j}$ 表示在第 $i$ 天时一共打扫了 $j$ 次最少可以使得房间内剩余多少垃圾，转移时枚举当前天数 $i$ 与操作次数 $j$ ，讨论转移即可，则有：

\begin{aligned} \forall 0 \leq j \leq i, & f_{i - 1, j} + m_{i} \to f_{i, j} \\ \forall 1 \leq j \leq i, & max (f_{i - 1, j - 1} + m_{i} - c_{i}, 0) \to f_{i, j} \end{aligned}

$\begin{aligned} &\forall 0\le j\le i, &f_{i - 1, j} + m_i \rightarrow f_{i, j}\\ &\forall 1\le j\le i, &\max(f_{i - 1, j - 1} + m_i - c_i, 0) \rightarrow f_{i, j} \end{aligned}$

特别地，当第 $i$ 天需要被检查时，需要检查是否有 $\forall 0\le j\le i, f_{i, j} = 0$ ，若没有则无解，否则需要将所有 $f_{i, j}\not= 0$ 设为 $+\infin$ 表示该状态之后无贡献。

答案即为最后一次检查时最小的满足 $f_{i, j}=0$ 的 $j$ 。

总时间复杂度 $O(n^2)$ 级别。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 1010;
const LL kInf = 1e18 + 2077;
//=============================================================
int n, d, m[kN], c[kN];
bool v[kN];
LL f[kN][kN];
//=============================================================
//=============================================================
int main() {
  // freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  std::cin >> n >> d;
 
  for (int i = 1; i <= n; ++ i) {
    std::cin >> m[i] >> c[i];
  }
  for (int i = 1; i <= d; ++ i) {
    int x; std::cin >> x;
    v[x] = 1;
  }
 
 
  for (int i = 1; i <= n; ++ i) {
    for (int j = 0; j <= n; ++ j) {
      f[i][j] = kInf;
    }
  }
 
  int flag = 0, ans = 0;
  for (int i = 1; i <= n; ++ i) {
    for (int j = 0; j <= i; ++ j) {
      if (j > 0) 
        f[i][j] = std::min(f[i][j], std::max(f[i - 1][j - 1] + m[i] - c[i], 0ll));
      f[i][j] = std::min(f[i][j], f[i - 1][j] + m[i]);
    }
 
    if (v[i]) {
      ans = n + 1;
      for (int j = 0; j <= i; ++ j) {
        if (f[i][j] == 0) {
          ans = j;
          break;
        }
      }
      if (ans == n + 1) flag = 1;
      for (int j = 0; j <= i; ++ j) {
        if (j < ans) f[i][j] = kInf;
      }
    }
  }
 
  if (flag) std::cout << -1 << "\n";
  else std::cout << ans << "\n";
  return 0;
}
/*
1 1
100 1
1
*/

G

二维偏序。

妈的题面怎么这么难读

记点： $O(0, 0)$ ， $X(x, 0)$ ， $A(x_i, y_i)$ ， $B(x_j, y_j)$ 。

发现对于点 $A$ ，点 $B$ 被包含在三角形 $\triangle AOX$ 等价于 $\triangle BOX$ 被包含在 $\triangle AOX$ 中。则充要条件为：

{\begin{cases} ∠ B O X \leq ∠ A O X \\ ∠ B X O \leq ∠ A X O \end{cases}

$\begin{cases} \angle BOX \le \angle AOX\\ \angle BXO \le \angle AXO \end{cases}$

发现是一个二维偏序问题，于是考虑求得上述两个角度的偏序关系后树状数组求解即可。

总时间复杂度 $O(n\log n)$ 级别。

 #include <bits/stdc++.h>
 
using namespace std;
using LL = long long;
const int N = 1e5 + 10;
int n, x; LL ans[N];
struct node {
    int x, y, v, id, d;
} p[N];
 
LL sum[N];
void add(int k, int x) {
    for ( ; k <= n; k += (k & -k)) sum[k] += x;
}
LL qry(int k) {
    LL res = 0;
    for ( ; k; k ^= (k & -k)) res += sum[k];
    return res;
}
inline bool cmp2(const node &g, const node &h) {
    return 1ll * (h.x - x) * g.y > 1ll * (g.x - x) * h.y;
}
inline bool cmp1(const node &g, const node &h) {
    return 1ll * h.x * g.y < 1ll * g.x * h.y;
}
 
int main() {
    cin >> n >> x;
    for (int i = 1; i <= n; i++) {
        cin >> p[i].x >> p[i].y >> p[i].v;
        p[i].id = i;
    }
    sort(p + 1, p + n + 1, cmp2);
    for (int i = 1; i <= n; i++) p[i].d = i;
    sort(p + 1, p + n + 1, cmp1);
    for (int i = 1; i <= n; i++) {
        ans[p[i].id] = qry(p[i].d);
        add(p[i].d, p[i].v);
    }
    for (int i = 1; i <= n; i++) cout << ans[i] << "\n";
    return 0;
}

D

构造。

Code by Saya_Alter_：

 #include <bits/stdc++.h>
#define mod 998244353
using namespace std;
using LL = long long;
// #define int long long
const int N = 5e5 + 10;
LL K, f[500][12], nex[12], g[12];
string s, t = "ATELLITE", ans, st = "SATELLITE";
 
 
void solve() {
    cin >> K;
    int i;
    for (i = 1; f[i - 1][8] <= K; i++) {
        s += t;
        memset(f[i], 0, sizeof(f[i]));
        f[i][0] = 1;
        for (int j = 0; j < s.size(); j++) {
            nex[0] = 1;
            for (int k = 0; k < 8; k++) {
                nex[k + 1] = f[i][k + 1];
                if (s[j] == t[k]) nex[k + 1] += f[i][k];
            }
            swap(f[i], nex);
        }
        // cout << f[i][8] << " ";
    }
    // cout << "\n";
    // cout << i << " ";
    for (int j = i - 2; j >= 1; j--) {
        for (int o = 1; o <= K / f[j][8]; o++) ans += 'S';
        K %= f[j][8];
        ans += t;
    }
    g[0] = 1;
    for (int j = 0; j < ans.size(); j++) {
        nex[0] = 1;
        for (int k = 0; k < 9; k++) {
            nex[k + 1] = g[k + 1];
            if (ans[j] == st[k]) nex[k + 1] += g[k];
        }
        swap(g, nex);
    }
    // cout << g[9] << "\n";
    // cout << ans.size() << "\n";
    cout << ans;
    // cout << "\n";
}
int main() {
    // ios::sync_with_stdio(false),cin.tie(0), cout.tie(0);
    int T = 1; 
    // cin >> T;
    while (T--) solve();
    return 0;
}
 
//1000000000000000000

写在最后

我是飞舞。

学到了什么：

I：发现可以缩小需要枚举的范围到很小的话直接大力搜！
G：转化为偏序问题。

posted @ 2024-03-29 10:34 Luckyblock 阅读(51) 评论(2) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· The 13th Shandong ICPC Provincial Collegiate Programming Contest

· 2024 ICPC National Invitational Collegiate Programming Contest, Wuhan Site

· The 2024 CCPC National Invitational Contest (Changchun) , The 17th Jilin Provincial Collegiate Programming Contest

· 2024天梯赛

· csp2024赛前集训

阅读排行：
· 全网最简单！3分钟用满血DeepSeek R1开发一款AI智能客服，零代码轻松接入微信、公众号、小程
· .NET 10 首个预览版发布，跨平台开发与性能全面提升
· 《HelloGitHub》第 107 期
· 全程使用 AI 从 0 到 1 写了个小工具
· 从文本到图像：SSE 如何助力 AI 内容实时呈现？（Typescript篇）

公告

MathJax 渲染格式改为 SVG，缩放倍率调至 125%，可获得更好的阅读效果。

博客首页仅显示部分高质量博文，大部分博文都位于随笔分类中。请善用下方的搜索功能。

大部分博文密码为某大质数。

昵称： Luckyblock
园龄： 5年5个月
粉丝： 242
关注： 149

+加关注

Luckyblock

身与华落，心将香飞

The 2024 Hunan Multi-School Programming Training Contest, Round 1

写在前面

A

B

C

I

K

L

F

G

D

写在最后

公告

搜索

积分与排名

随笔分类 (530)

相册 (32)

友链

阅读排行榜

最新评论

	//
	/*
	By:Luckyblock
	*/
	#include <bits/stdc++.h>
	#define LL long long
	//=============================================================
	//=============================================================
	//=============================================================
	int main() {
	//freopen("1.txt", "r", stdin);
	std::ios::sync_with_stdio(0), std::cin.tie(0);
	LL h, k, v, s, ans = 0;
	std::cin >> h >> k >> v >> s;
	while (h > 0) {
	v += s;
	v -= std::max(1ll, v / 10ll);

	if (v >= k) ++ h;
	else if (v > 0) -- h;
	else v = 0, h = 0;

	if (h <= 0) v = 0;

	ans += v;

	if (s > 0) -- s;
	}

	std::cout << ans << "\n";
	return 0;
	}

	#include<bits/stdc++.h>
	using namespace std;
	#define int long long
	int n,l,h;
	const int N=3e4+5;
	int a[N],b[N];
	int sum(int li,int ri){
	return b[ri]-b[li-1];
	}
	int f[N][2];//0 min 1 max
	signed main(){
	std::cin>>n>>l>>h;
	for(int i=1;i<=n;++i){
	cin>>a[i];
	b[i]=b[i-1]+a[i];
	}
	int minn=nnn,maxx=0;
	for(int i=l;i<=h;++i){
	for(int k=1;k<=i;++k){
	int tmp=sum(1,k);
	int num=0;
	if(tmp>0) num++;
	for(int j=k+1;j<=n;j+=i){
	int r=j+i-1;
	r=min(r,n);
	tmp=sum(j,r);
	if(tmp>0) ++num;
	}
	minn=min(minn,num);
	maxx=max(maxx,num);
	}
	}
	cout<<minn<<' '<<maxx<<endl;
	return 0;
	}

	#include <bits/stdc++.h>
	using namespace std;
	int n, A[10], B[10], o;
	char s[1010][5], S[30];
	bool vis[300], vis2[300], p[300];
	void dfs2(int k) {
	if (k == 7) {

	for (int i = 1; i <= n; i++) {
	int cnt = (int)vis2[s[i][0]] + (int)vis2[s[i][1]] + (int)vis2[s[i][2]];
	if (cnt != 1) return ;
	}
	for (int i = 1; i <= 6; i++) cout << S[A[i]]; cout << " ";
	for (int i = 1; i <= 6; i++) cout << S[B[i]]; cout << " ";
	for (int i = 1; i <= o; i++) if (!vis[S[i]] && !vis2[S[i]]) cout << S[i]; cout << " ";
	exit(0);
	}
	for (int i = B[k - 1] + 1; i <= o; i++)
	if (!vis[S[i]]) {
	B[k] = i;
	vis2[S[i]] = true;
	dfs2(k + 1);
	vis2[S[i]] = false;
	}
	}
	void dfs(int k) {
	if (k == 7) {

	for (int i = 1; i <= n; i++) {
	int cnt = (int)vis[s[i][0]] + (int)vis[s[i][1]] + (int)vis[s[i][2]];
	if (cnt != 1) return ;
	}
	dfs2(1);
	return ;
	}
	for (int i = A[k - 1] + 1; i <= o; i++)
	{
	A[k] = i;
	vis[S[i]] = true;
	dfs(k + 1);
	vis[S[i]] = false;
	}
	}

	int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
	cin >> s[i];
	if (s[i][0] == s[i][1] \|\| s[i][0] == s[i][2] \|\| s[i][1] == s[i][2]) {
	cout << "0\n";
	return 0;
	}
	p[s[i][0]] = p[s[i][1]] = p[s[i][2]] = true;
	}
	o = 0;
	for (char c = 'a'; c <= 'z'; c++) {
	if (p[c]) S[++o] = c;
	}
	if (o > 18) {
	cout << "0\n";
	return 0;
	}

	for (char c = 'a'; c <= 'z'; c++) {
	if (!p[c] && o < 18) S[++o] = c;
	}
	dfs(1);
	cout << "0\n";
	return 0;
	}

	#include <bits/stdc++.h>

	using namespace std;
	using LL = long long;
	const int N = 1e5 + 10;
	int n, x; LL ans[N];
	struct node {
	int x, y, v, id, d;
	} p[N];

	LL sum[N];
	void add(int k, int x) {
	for ( ; k <= n; k += (k & -k)) sum[k] += x;
	}
	LL qry(int k) {
	LL res = 0;
	for ( ; k; k ^= (k & -k)) res += sum[k];
	return res;
	}
	inline bool cmp2(const node &g, const node &h) {
	return 1ll * (h.x - x) * g.y > 1ll * (g.x - x) * h.y;
	}
	inline bool cmp1(const node &g, const node &h) {
	return 1ll * h.x * g.y < 1ll * g.x * h.y;
	}

	int main() {
	cin >> n >> x;
	for (int i = 1; i <= n; i++) {
	cin >> p[i].x >> p[i].y >> p[i].v;
	p[i].id = i;
	}
	sort(p + 1, p + n + 1, cmp2);
	for (int i = 1; i <= n; i++) p[i].d = i;
	sort(p + 1, p + n + 1, cmp1);
	for (int i = 1; i <= n; i++) {
	ans[p[i].id] = qry(p[i].d);
	add(p[i].d, p[i].v);
	}
	for (int i = 1; i <= n; i++) cout << ans[i] << "\n";
	return 0;
	}

	#include <bits/stdc++.h>
	#define mod 998244353
	using namespace std;
	using LL = long long;
	// #define int long long
	const int N = 5e5 + 10;
	LL K, f[500][12], nex[12], g[12];
	string s, t = "ATELLITE", ans, st = "SATELLITE";


	void solve() {
	cin >> K;
	int i;
	for (i = 1; f[i - 1][8] <= K; i++) {
	s += t;
	memset(f[i], 0, sizeof(f[i]));
	f[i][0] = 1;
	for (int j = 0; j < s.size(); j++) {
	nex[0] = 1;
	for (int k = 0; k < 8; k++) {
	nex[k + 1] = f[i][k + 1];
	if (s[j] == t[k]) nex[k + 1] += f[i][k];
	}
	swap(f[i], nex);
	}
	// cout << f[i][8] << " ";
	}
	// cout << "\n";
	// cout << i << " ";
	for (int j = i - 2; j >= 1; j--) {
	for (int o = 1; o <= K / f[j][8]; o++) ans += 'S';
	K %= f[j][8];
	ans += t;
	}
	g[0] = 1;
	for (int j = 0; j < ans.size(); j++) {
	nex[0] = 1;
	for (int k = 0; k < 9; k++) {
	nex[k + 1] = g[k + 1];
	if (ans[j] == st[k]) nex[k + 1] += g[k];
	}
	swap(g, nex);
	}
	// cout << g[9] << "\n";
	// cout << ans.size() << "\n";
	cout << ans;
	// cout << "\n";
	}
	int main() {
	// ios::sync_with_stdio(false),cin.tie(0), cout.tie(0);
	int T = 1;
	// cin >> T;
	while (T--) solve();
	return 0;
	}

	//1000000000000000000