結果

問題 No.3455 N-beatsu
コンテスト
ユーザー raaaaaaaaa
提出日時 2026-02-28 15:36:04
言語 C++23
(gcc 15.2.0 + boost 1.89.0)
コンパイル:
g++-15 -O2 -lm -std=c++23 -Wuninitialized -DONLINE_JUDGE -o a.out _filename_
実行:
./a.out
結果
AC  
実行時間 115 ms / 2,000 ms
コード長 8,307 bytes
記録
記録タグの例:
初AC ショートコード 純ショートコード 純主流ショートコード 最速実行時間
コンパイル時間 3,728 ms
コンパイル使用メモリ 351,872 KB
実行使用メモリ 7,844 KB
最終ジャッジ日時 2026-02-28 15:36:10
合計ジャッジ時間 5,253 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other AC * 10
権限があれば一括ダウンロードができます

ソースコード

diff #
raw source code 

#include <bits/stdc++.h>
#include <math.h>
#include <algorithm>
using namespace std;
int getketa(int num, int idx)
{
    return (num % ((int)pow(10, idx))) / ((int)pow(10, idx - 1));
}

// 配列が下位文化を判定
bool isKaibun(vector<int> a)
{
    for (int i = 0; i < a.size(); i++)
    {
        if (a.at(i) != a.at(a.size() - i - 1))
        {
            return false;
        }
    }
    return true;
}

vector<long long> inputary(int n)
{
    vector<long long> r;
    for (int i = 0; i < n; i++)
    {
        int a;
        cin >> a;
        r.push_back(a);
    }
    return r;
}

vector<string> inputstrary(int n)
{
    vector<string> r;
    for (int i = 0; i < n; i++)
    {
        string a;
        cin >> a;
        r.push_back(a);
    }
    return r;
}

void check(vector<int> s)
{
    int fisrt = s.at(0);
    int last = s.at(s.size() - 1);
    vector<int> nibai = s;
    for (int i = 0; i < s.size(); i++)
    {
        if (s.at(i) * 2 >= last)
        {
            cout << i + 1 << endl;
            return;
        }

        vector<int> bufnibai;
        for (int j = 0; j < nibai.size(); j++)
        {
            if (i == s.size())
                break;
            if (nibai.at(j) * 2 <= s.at(i + 1))
            {
                bufnibai.push_back(nibai.at(j));
            }
        }
        nibai = bufnibai;

        // int m = *max_element(nibai.begin(), nibai.end());
    }

    cout << -1 << endl;
}

std::vector<std::string> split(std::string str, char del)
{
    std::vector<std::string> result;
    std::string subStr;

    for (const char c : str)
    {
        if (c == del)
        {
            result.push_back(subStr);
            subStr.clear();
        }
        else
        {
            subStr += c;
        }
    }

    result.push_back(subStr);
    return result;
}

// 桁数を返す
int GetDigit(int num)
{
    return log10(num) + 1;
}
const double PI = 3.1415926535897932384626433832795028841971;

int efu(int x)
{
    int sum = 0;
    int ketasuu = GetDigit(x);
    // cout << ketasuu;
    for (int i = 0; i < ketasuu; i++)
    {
        sum += getketa(x, i + 1);
    }

    return sum;
}

struct choten
{
    int number = 0;
    bool color = false;
};

#include <bits/stdc++.h>
using namespace std;

string s;

bool isA(int k)
{
    return s.at(k) == 'a';
}

vector<long long> ruiseki_a;
vector<long long> ruiseki_b;

int get_a_count(int l, int r)
{
    return ruiseki_a.at(r) - ruiseki_a.at(l);
}

int get_b_count(int l, int r)
{
    return ruiseki_b.at(r) - ruiseki_b.at(l);
}

vector<int> h;
vector<int> b;

// bool isOK(int index) {
//     for(auto body : b){
//         if(body >= h.at(index)){
//             h.erase(h.begin() + index);
//             return true;
//         }
//     }

//     return false;
// }

// 汎用的な二分探索のテンプレ
// int binary_search() {
//     int ng = -1; //「index = 0」が条件を満たすこともあるので、初期値は -1
//     int ok = h.size(); // 「index = a.size()-1」が条件を満たさないこともあるので、初期値は a.size()

//     /* ok と ng のどちらが大きいかわからないことを考慮 */
//     while (abs(ok - ng) > 1) {
//         int mid = (ok + ng) / 2;

//         if (isOK(mid)) ok = mid;
//         else ng = mid;
//     }
//     return ok;
// }

struct point
{
    int kekkyoku_h;
    int toreru_min;
    int toreru_max;
    int t, l, u;
};

struct testcase
{
    int n, h;
    vector<point> points;
};

#define pymod(a, b) ((0 <= ((a) ^ (b))) ? (a) % (b) : ((a) % (b) + (b)) % (b))

struct ppair
{
    int x, y;
    bool is_xok = false, is_yok = false;
    bool isOK()
    {
        return is_xok || is_yok;
    };
};

void run(vector<unsigned int> &a)
{
    if (a.size() < 3)
    {
        return;
    }
    bool flag = false;
    for (int k = 0; k < a.size() - 3; k++)
    {
        if (a.at(k) == a.at(k + 1) && a.at(k + 1) == a.at(k + 2) && a.at(k + 2) == a.at(k + 3))
        {
            a.erase(a.begin() + k, a.begin() + k + 4);
            flag = true;
            break;
        }
    }

    // 条件を満たす並びが見つからなかった場合
    if (!flag)
    {
        return;
    }

    run(a);
}

vector<long long> inputary2(int n)
{
    vector<long long> r;
    for (int i = 0; i < n; i++)
    {
        int a;
        cin >> a;
        r.push_back(a);
    }
    return r;
}



// // index が条件を満たすかどうか
// bool isOK(int index, int key, const vector<int> &a)
// {
//     if (a[index] > key)
//         return true;
//     else
//         return false;
// }

// // 汎用的な二分探索のテンプレ
// int binary_search(int key, const vector<int> &a)
// {
//     int left = -1;             // 「index = 0」が条件を満たすこともあるので、初期値は -1
//     int right = (int)a.size(); // 「index = a.size()-1」が条件を満たさないこともあるので、初期値は a.size()

//     /* どんな二分探索でもここの書き方を変えずにできる！ */
//     while (right - left > 1)
//     {
//         int mid = left + (right - left) / 2;

//         if (isOK(mid, key, a))
//             right = mid;
//         else
//             left = mid;
//     }

//     /* left は条件を満たさない最大の値、right は条件を満たす最小の値になっている */
//     return left;
// }

vector<long long> get_keta_vector(long long num)
{
    vector<long long> a;
    for (long long i = GetDigit(num); i >= 1; i--)
    {
        a.push_back(getketa(num, i));
    }
    return a;
}

bool isOK(vector<long long> s)
{
    if (s.size() % 2 != 0){
        return false;
    }
    auto len = s.size();
    bool flag = false;
    for (long long k = 0; k < len / 2; k++)
    {
        if (s.at(k) != s.at(k + len / 2))
        {
            flag = true;
            break;
        }
    }
    return !flag;
}

long long run(long long n)
{
    long long left = -1;
    long long right = n;
    while (right - left > 1)
    {
        long long mid = left + (right - left) / 2;

        auto s = get_keta_vector(mid);
        if (isOK(s)) {
            right = mid;
        }else{
            left = mid;
        }
    }

    return right;
}

vector<int> a = {1, 14, 32, 51, 51, 51, 243, 419, 750, 910};

// index が条件を満たすかどうか
bool isOK(int index, int key) {
    if (a[index] >= key) return true;
    else return false;
}

// 汎用的な二分探索のテンプレ
int binary_search(int key, int right) {
    int left = -1; //「index = 0」が条件を満たすこともあるので、初期値は -1
    //int right = (int)a.size(); // 「index = a.size()-1」が条件を満たさないこともあるので、初期値は a.size()
    
    /* どんな二分探索でもここの書き方を変えずにできる！ */
    while (right - left > 1) {
        int mid = left + (right - left) / 2;

        if (isOK(mid, key)) right = mid;
        else left = mid;
    }
    
    /* left は条件を満たさない最大の値、right は条件を満たす最小の値になっている */
    return right;
}

// vector<long long> xs;



int main()
{
    int n, q;
    cin >> n >> q;

    vector<int> n_ketas;
    for(int i = GetDigit(n); i > 0; i--){
        n_ketas.push_back(getketa(n, i));
        
    }


    vector<int> xlist;
    for(int i = 0; i < q; i++){
        int x;
        cin >> x;
        xlist.push_back(x);
    }

    for(auto x : xlist){
        vector<int> x_ketas;
        for(int i = GetDigit(x); i > 0; i--){
            x_ketas.push_back(getketa(x, i));
        }
        //i=オフセット
        bool isBubun = false;
        if(true){
            for(int i = 0; i < GetDigit(x)-GetDigit(n)+1; i++){
                bool flag = true;
                for(int k = 0; k < GetDigit(n); k++){
                    if(x_ketas.at(i+k) != n_ketas.at(k)){
                        flag = false;//一か所でも違うところがアレば、そのiはダメ
                    }
                }

                if(flag){
                    isBubun = true;
                    break;
                }
            }
        }

        if(isBubun || x%n == 0){
            cout << "Yes" << endl;
        }else{
            
            cout << "No" << endl;
        }

    }

    return 0;
}
0