#779169 (C) No.59 鉄道の旅

提出ソース

結果

問題	No.59 鉄道の旅
ユーザー	nonamae
提出日時	2022-07-16 13:31:51
言語	C (gcc 12.3.0)
結果	AC
実行時間	17 ms / 5,000 ms
コード長	5,677 bytes
コンパイル時間	1,445 ms
コンパイル使用メモリ	37,480 KB
実行使用メモリ	9,904 KB
最終ジャッジ日時	2023-09-10 22:04:02
合計ジャッジ時間	1,607 ms
ジャッジサーバーID （参考情報）	judge13 / judge12

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 4,376 KB
testcase_01	AC	1 ms 4,376 KB
testcase_02	AC	1 ms 4,384 KB
testcase_03	AC	1 ms 4,380 KB
testcase_04	AC	17 ms 9,904 KB
testcase_05	AC	1 ms 4,384 KB
testcase_06	AC	1 ms 4,380 KB
testcase_07	AC	1 ms 4,380 KB
testcase_08	AC	9 ms 9,340 KB
testcase_09	AC	10 ms 8,852 KB
testcase_10	AC	8 ms 8,192 KB
testcase_11	AC	1 ms 4,380 KB
testcase_12	AC	2 ms 4,384 KB
testcase_13	AC	7 ms 4,380 KB
testcase_14	AC	7 ms 4,376 KB
testcase_15	AC	0 ms 4,380 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#pragma region opt

#pragma GCC target("avx2")
#pragma GCC optimize("O3")

#pragma endregion opt


#pragma region header

#define _GNU_SOURCE
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <time.h>

#pragma endregion header


#pragma region type

typedef   int8_t      i8;
typedef   int16_t     i16;
typedef   int32_t     i32;
typedef   int64_t     i64;
typedef __int128_t    i128;

typedef   uint8_t     u8;
typedef   uint16_t    u16;
typedef   uint32_t    u32;
typedef   uint64_t    u64;
typedef __uint128_t   u128;

typedef   float       f32;
typedef   double      f64;
typedef   long double f80;

#pragma endregion type


#pragma region macro

#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define SWAP(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b)))
#define POPCNT32(a) __builtin_popcount((a))
#define POPCNT64(a) __builtin_popcountll((a))
#define CTZ32(a) __builtin_ctz((a))
#define CLZ32(a) __builtin_clz((a))
#define CTZ64(a) __builtin_ctzll((a))
#define CLZ64(a) __builtin_clzll((a))
#define HAS_SINGLE_BIT32(a) (__builtin_popcount((a)) == (1))
#define HAS_SINGLE_BIT64(a) (__builtin_popcountll((a)) == (1))
#define MSB32(a) ((31) - __builtin_clz((a)))
#define MSB64(a) ((63) - __builtin_clzll((a)))
#define BIT_WIDTH32(a) ((a) ? ((32) - __builtin_clz((a))) : (0))
#define BIT_WIDTH64(a) ((a) ? ((64) - __builtin_clzll((a))) : (0))
#define LSBit(a) ((a) & (-(a)))
#define CLSBit(a) ((a) & ((a) - (1)))
#define BIT_CEIL32(a) ((!(a)) ? (1) : ((POPCNT32(a)) == (1) ? ((1u) << ((31) - CLZ32((a)))) : ((1u) << ((32) - CLZ32(a)))))
#define BIT_CEIL64(a) ((!(a)) ? (1) : ((POPCNT64(a)) == (1) ? ((1ull) << ((63) - CLZ64((a)))) : ((1ull) << ((64) - CLZ64(a)))))
#define BIT_FLOOR32(a) ((!(a)) ? (0) : ((1u) << ((31) - CLZ32((a)))))
#define BIT_FLOOR64(a) ((!(a)) ? (0) : ((1ull) << ((63) - CLZ64((a)))))
#define _ROTL32(x, s) (((x) << ((s) % (32))) | (((x) >> ((32) - ((s) % (32))))))
#define _ROTR32(x, s) (((x) >> ((s) % (32))) | (((x) << ((32) - ((s) % (32))))))
#define ROTL32(x, s) (((s) == (0)) ? (x) : ((((i64)(s)) < (0)) ? (_ROTR32((x), -(s))) : (_ROTL32((x), (s)))))
#define ROTR32(x, s) (((s) == (0)) ? (x) : ((((i64)(s)) < (0)) ? (_ROTL32((x), -(s))) : (_ROTR32((x), (s)))))
#define _ROTL64(x, s) (((x) << ((s) % (64))) | (((x) >> ((64) - ((s) % (64))))))
#define _ROTR64(x, s) (((x) >> ((s) % (64))) | (((x) << ((64) - ((s) % (64))))))
#define ROTL64(x, s) (((s) == (0)) ? (x) : ((((i128)(s)) < (0)) ? (_ROTR64((x), -(s))) : (_ROTL64((x), (s)))))
#define ROTR64(x, s) (((s) == (0)) ? (x) : ((((i128)(s)) < (0)) ? (_ROTL64((x), -(s))) : (_ROTR64((x), (s)))))

#pragma endregion macro


#pragma region io

// -2147483648 ～ 2147483647 (> 10 ^ 9)
i32 in_i32(void) {
    i32 c, x = 0, f = 1;
    while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f;
    while (47 < c && c < 58) {
        x = x * 10 + c - 48;
        c = getchar_unlocked();
    }
    return f * x;
}

static inline void out_i32_inner(i32 x) {
    if (x >= 10) out_i32_inner(x / 10);
    putchar_unlocked(x - x / 10 * 10 + 48);
}

void out_i32(i32 x) {
    if (x < 0) {
        putchar_unlocked('-');
        x = -x;
    }
    out_i32_inner(x);
}

// -9223372036854775808 ～ 9223372036854775807 (> 10 ^ 18)
i64 in_i64(void) {
    i64 c, x = 0, f = 1;
    while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f;
    while (47 < c && c < 58) {
        x = x * 10 + c - 48;
        c = getchar_unlocked();
    }
    return f * x;
}

static inline void out_i64_inner(i64 x) {
    if (x >= 10) out_i64_inner(x / 10);
    putchar_unlocked(x - x / 10 * 10 + 48);
}

void out_i64(i64 x) {
    if (x < 0) {
        putchar_unlocked('-');
        x = -x;
    }
    out_i64_inner(x);
}

// 0 ～ 4294967295 (> 10 ^ 9)
u32 in_u32(void) {
    u32 c, x = 0;
    while (c = getchar_unlocked(), c < 48 || c > 57);
    while (47 < c && c < 58) {
        x = x * 10 + c - 48;
        c = getchar_unlocked();
    }
    return x;
}

void out_u32(u32 x) {
    if (x >= 10) out_u32(x / 10);
    putchar_unlocked(x - x / 10 * 10 + 48);
}

// 0 ～ 18446744073709551615 (> 10 ^ 19)
u64 in_u64(void) {
    u64 c, x = 0;
    while (c = getchar_unlocked(), c < 48 || c > 57);
    while (47 < c && c < 58) {
        x = x * 10 + c - 48;
        c = getchar_unlocked();
    }
    return x;
}

void out_u64(u64 x) {
    if (x >= 10) out_u64(x / 10);
    putchar_unlocked(x - x / 10 * 10 + 48);
}

void NL(void) { putchar_unlocked('\n'); }

void SP(void) { putchar_unlocked(' '); }

#pragma endregion io


#pragma region Binary Indexed Tree

i64 *create_BIT(i64 BIT_len) {
    i64 *ret = (i64 *)calloc(BIT_len, sizeof(i64));
    return ret;
}

void add_BIT(i64 *BIT, i64 BIT_len, i64 x, i64 y) {
    for (i64 i = x; i < BIT_len; i += LSBit(i)) BIT[i] += y;
}

i64 sum_BIT(i64 *BIT, i64 x) {
    i64 ret = 0;
    for (i64 i = x; i > 0; i -= LSBit(i)) ret += BIT[i];
    return ret;
}

#pragma endregion Binary Indexed Tree


int main(void) {

    i64 N = in_i64();
    i64 K = in_i64();

    i64 *w = (i64 *)calloc(N, sizeof(i64));
    for (int i = 0; i < N; ++i) w[i] = in_i64();

    i64 *tree = create_BIT(1000001);

    for (int i = 0; i < N; ++i) {
        if (w[i] > 0) {
            if ((sum_BIT(tree, 1000000) - sum_BIT(tree, w[i] - 1)) >= K) continue;
            add_BIT(tree, 1000001, w[i], 1);
        }
        else {
            if ((sum_BIT(tree, -w[i]) - sum_BIT(tree, -w[i] - 1)) > 0) add_BIT(tree, 1000001, -w[i], -1);
        }
    }
    
    out_i64(sum_BIT(tree, 1000000));
    NL();

    free(tree);

    return 0;
}

yukicoder

結果

テストケース

ソースコード