diff --git a/docs/guides/how-to-add-contest-table-provider.md b/docs/guides/how-to-add-contest-table-provider.md
index dd43c4758..db29b19db 100644
--- a/docs/guides/how-to-add-contest-table-provider.md
+++ b/docs/guides/how-to-add-contest-table-provider.md
@@ -116,11 +116,12 @@ AOJ/JAG 固有の詳細（`AOJ_LABEL_OVERRIDES`、`titleStyle`、同一年2回
 | NDPC                        | `'ndpc'`                | 20問   | A～T         |
 | FPS_24                      | `'fps-24'`              | 24問   | A～X         |
 | GAME_24‡                    | `'game-24'`             | 24問   | A～X         |
+| AALC                        | `'aalc001'`             | 24問   | A～X         |
 | ACL_PRACTICE                | `'practice2'`           | 12問   | A～L         |
 | ACL_BEGINNER / ACL_CONTEST1 | `'abl'`/`'acl1'`        | 6問    | A～F         |
 | AWC0100 / AWC0150†          | `'awc0100'`/`'awc0150'` | 15問   | A～O         |
 
-†注: ContestType.AWC を再利用し、section（`'0100'`, `'0150'`, `'0151Onwards'`）で provider key を一意化。ACL 系は `Acl` グループ、DP 系は `dps` グループで統一管理。
+†注: ContestType.AWC を再利用し、section（`'0100'`, `'0150'`, `'0151Onwards'`）で provider key を一意化。ACL 系は `Acl` グループ、DP 系と x 24 題系（FPS_24 / GAME_24 / AALC）は `dps` グループで統一管理。
 
 ‡注: task_id は `game_a`〜`game_x` で、contest_id の数字を含まない（`fps-24` は `fps_24_a`）。
 
@@ -169,4 +170,4 @@ AOJ/JAG 固有の詳細（`AOJ_LABEL_OVERRIDES`、`titleStyle`、同一年2回
 
 ---
 
-**最終更新**: 2026-09-05
+**最終更新**: 2026-10-13
diff --git a/e2e/problems_contest_table.spec.ts b/e2e/problems_contest_table.spec.ts
index 669eb54f4..e80757b1e 100644
--- a/e2e/problems_contest_table.spec.ts
+++ b/e2e/problems_contest_table.spec.ts
@@ -7,10 +7,13 @@ const XDPC_GROUP_TABLE_TITLES = [
   'Next DP Contest',
   'FPS 24 題',
   '組合せゲーム 24 題',
+  "AAL Contest 001: Let's use segtree!",
 ];
 
 test.describe('xDPC group in contest table', () => {
-  test('shows Game 24 table right after FPS 24 in the xDPC group', async ({ page }) => {
+  test('shows Game 24 and AAL Contest 001 tables after FPS 24 in the xDPC group', async ({
+    page,
+  }) => {
     await page.goto('/problems');
 
     await page.getByRole('button', { name: XDPC_GROUP_ARIA_LABEL }).click();
diff --git a/prisma/migrations/20261013091828_add_aalc_to_contest_type/migration.sql b/prisma/migrations/20261013091828_add_aalc_to_contest_type/migration.sql
new file mode 100644
index 000000000..6b16f97cc
--- /dev/null
+++ b/prisma/migrations/20261013091828_add_aalc_to_contest_type/migration.sql
@@ -0,0 +1,2 @@
+-- AlterEnum
+ALTER TYPE "ContestType" ADD VALUE 'AALC';
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 61114f9d1..66429fced 100755
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -315,6 +315,7 @@ enum ContestType {
   UNIVERSITY // University Programming Contests in AtCoder (e.g., UTPC)
   FPS_24 // 24 Problems on Formal Power Series
   GAME_24 // 24 Problems on Combinatorial Games
+  AALC // AAL Contest 001: Let's use segtree!
   ATCODER_MAIN_OFFICIAL_ONSITE // AtCoder World Tour Finals (official onsite finals)
   OTHERS // AtCoder (その他)
   AOJ_COURSES // AIZU ONLINE JUDGE Courses
diff --git a/prisma/tasks.ts b/prisma/tasks.ts
index 25279adb2..348f5f7bb 100755
--- a/prisma/tasks.ts
+++ b/prisma/tasks.ts
@@ -8935,6 +8935,174 @@ export const tasks = [
     name: 'Bacteria Growth Experiment',
     title: 'A. Bacteria Growth Experiment',
   },
+  {
+    id: 'aalc001_x',
+    contest_id: 'aalc001',
+    problem_index: 'X',
+    name: 'Unevenness',
+    title: 'X. Unevenness',
+  },
+  {
+    id: 'aalc001_w',
+    contest_id: 'aalc001',
+    problem_index: 'W',
+    name: 'Adjacent Add',
+    title: 'W. Adjacent Add',
+  },
+  {
+    id: 'aalc001_v',
+    contest_id: 'aalc001',
+    problem_index: 'V',
+    name: 'Connectivity 2',
+    title: 'V. Connectivity 2',
+  },
+  {
+    id: 'aalc001_u',
+    contest_id: 'aalc001',
+    problem_index: 'U',
+    name: 'Second',
+    title: 'U. Second',
+  },
+  {
+    id: 'aalc001_t',
+    contest_id: 'aalc001',
+    problem_index: 'T',
+    name: 'K-Inversion Count',
+    title: 'T. K-Inversion Count',
+  },
+  {
+    id: 'aalc001_s',
+    contest_id: 'aalc001',
+    problem_index: 'S',
+    name: 'Absolute Value',
+    title: 'S. Absolute Value',
+  },
+  {
+    id: 'aalc001_r',
+    contest_id: 'aalc001',
+    problem_index: 'R',
+    name: 'Connectivity',
+    title: 'R. Connectivity',
+  },
+  {
+    id: 'aalc001_q',
+    contest_id: 'aalc001',
+    problem_index: 'Q',
+    name: 'Number of Moves',
+    title: 'Q. Number of Moves',
+  },
+  {
+    id: 'aalc001_p',
+    contest_id: 'aalc001',
+    problem_index: 'P',
+    name: 'Connect the Dots',
+    title: 'P. Connect the Dots',
+  },
+  {
+    id: 'aalc001_o',
+    contest_id: 'aalc001',
+    problem_index: 'O',
+    name: 'Minimum Value',
+    title: 'O. Minimum Value',
+  },
+  {
+    id: 'aalc001_n',
+    contest_id: 'aalc001',
+    problem_index: 'N',
+    name: 'Times Tables',
+    title: 'N. Times Tables',
+  },
+  {
+    id: 'aalc001_m',
+    contest_id: 'aalc001',
+    problem_index: 'M',
+    name: 'NAND',
+    title: 'M. NAND',
+  },
+  {
+    id: 'aalc001_l',
+    contest_id: 'aalc001',
+    problem_index: 'L',
+    name: 'Swap between Arrays',
+    title: 'L. Swap between Arrays',
+  },
+  {
+    id: 'aalc001_k',
+    contest_id: 'aalc001',
+    problem_index: 'K',
+    name: 'Multiset',
+    title: 'K. Multiset',
+  },
+  {
+    id: 'aalc001_j',
+    contest_id: 'aalc001',
+    problem_index: 'J',
+    name: 'Long Binary String',
+    title: 'J. Long Binary String',
+  },
+  {
+    id: 'aalc001_i',
+    contest_id: 'aalc001',
+    problem_index: 'I',
+    name: 'Subarray',
+    title: 'I. Subarray',
+  },
+  {
+    id: 'aalc001_h',
+    contest_id: 'aalc001',
+    problem_index: 'H',
+    name: 'Add and Mod',
+    title: 'H. Add and Mod',
+  },
+  {
+    id: 'aalc001_g',
+    contest_id: 'aalc001',
+    problem_index: 'G',
+    name: 'Sum of k-th Powers',
+    title: 'G. Sum of k-th Powers',
+  },
+  {
+    id: 'aalc001_f',
+    contest_id: 'aalc001',
+    problem_index: 'F',
+    name: 'Run',
+    title: 'F. Run',
+  },
+  {
+    id: 'aalc001_e',
+    contest_id: 'aalc001',
+    problem_index: 'E',
+    name: 'RGB',
+    title: 'E. RGB',
+  },
+  {
+    id: 'aalc001_d',
+    contest_id: 'aalc001',
+    problem_index: 'D',
+    name: 'Inversion Count',
+    title: 'D. Inversion Count',
+  },
+  {
+    id: 'aalc001_c',
+    contest_id: 'aalc001',
+    problem_index: 'C',
+    name: 'Binary Search on a Segment Tree',
+    title: 'C. Binary Search on a Segment Tree',
+  },
+  {
+    id: 'aalc001_b',
+    contest_id: 'aalc001',
+    problem_index: 'B',
+    name: 'Lazy Segment Tree',
+    title: 'B. Lazy Segment Tree',
+  },
+  {
+    id: 'aalc001_a',
+    contest_id: 'aalc001',
+    problem_index: 'A',
+    name: 'Segment Tree',
+    title: 'A. Segment Tree',
+  },
   {
     id: 'game_x',
     contest_id: 'game-24',
diff --git a/src/features/tasks/utils/contest-table/aalc_provider.test.ts b/src/features/tasks/utils/contest-table/aalc_provider.test.ts
new file mode 100644
index 000000000..b89fd0200
--- /dev/null
+++ b/src/features/tasks/utils/contest-table/aalc_provider.test.ts
@@ -0,0 +1,108 @@
+import { describe, test, expect } from 'vitest';
+
+import { ContestType } from '$lib/contests/types/contest';
+import type { TaskResults } from '$lib/types/task';
+
+import { AALCProvider } from './aalc_provider';
+
+describe('AALCProvider', () => {
+  test('expects to get correct metadata', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const metadata = provider.getMetadata();
+
+    expect(metadata.title).toBe("AAL Contest 001: Let's use segtree!");
+    expect(metadata.abbreviationName).toBe('aalc001');
+  });
+
+  test('expects to get correct display configuration', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const displayConfig = provider.getDisplayConfig();
+
+    expect(displayConfig.isShownHeader).toBe(false);
+    expect(displayConfig.isShownRoundLabel).toBe(false);
+    expect(displayConfig.roundLabelWidth).toBe('');
+    expect(displayConfig.tableBodyCellsWidth).toBe(
+      'w-1/2 xs:w-1/3 sm:w-1/4 md:w-1/5 lg:w-1/6 2xl:w-1/7 px-1 py-2',
+    );
+    expect(displayConfig.isShownTaskIndex).toBe(true);
+  });
+
+  test('expects to format contest round label correctly', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const label = provider.getContestRoundLabel('');
+
+    expect(label).toBe('');
+  });
+
+  test('expects to filter tasks to include only aalc001 contest', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const mixedTasks = [
+      { contest_id: 'abc123', task_id: 'abc123_a', task_table_index: 'A' },
+      { contest_id: 'aalc001', task_id: 'aalc001_a', task_table_index: 'A' },
+      { contest_id: 'game-24', task_id: 'game_a', task_table_index: 'A' },
+      { contest_id: 'aalc001', task_id: 'aalc001_b', task_table_index: 'B' },
+    ];
+    const filtered = provider.filter(mixedTasks as TaskResults);
+
+    expect(filtered?.map((task) => task.task_id)).toEqual(['aalc001_a', 'aalc001_b']);
+  });
+
+  test('expects to generate correct table structure', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const tasks = [
+      { contest_id: 'aalc001', task_id: 'aalc001_a', task_table_index: 'A' },
+      { contest_id: 'aalc001', task_id: 'aalc001_b', task_table_index: 'B' },
+      { contest_id: 'aalc001', task_id: 'aalc001_x', task_table_index: 'X' },
+    ];
+    const table = provider.generateTable(tasks as TaskResults);
+
+    expect(table).toHaveProperty('aalc001');
+    expect(table['aalc001']).toHaveProperty('A');
+    expect(table['aalc001']).toHaveProperty('B');
+    expect(table['aalc001']).toHaveProperty('X');
+    expect(table['aalc001']['A']).toEqual(expect.objectContaining({ task_id: 'aalc001_a' }));
+  });
+
+  test('expects to get contest round IDs correctly', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const tasks = [
+      { contest_id: 'aalc001', task_id: 'aalc001_a', task_table_index: 'A' },
+      { contest_id: 'aalc001', task_id: 'aalc001_x', task_table_index: 'X' },
+    ];
+    const roundIds = provider.getContestRoundIds(tasks as TaskResults);
+
+    expect(roundIds).toEqual(['aalc001']);
+  });
+
+  test('expects to get header IDs for tasks correctly in ascending order', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const tasks = [
+      { contest_id: 'aalc001', task_id: 'aalc001_a', task_table_index: 'A' },
+      { contest_id: 'aalc001', task_id: 'aalc001_x', task_table_index: 'X' },
+      { contest_id: 'aalc001', task_id: 'aalc001_m', task_table_index: 'M' },
+      { contest_id: 'aalc001', task_id: 'aalc001_b', task_table_index: 'B' },
+    ];
+    const headerIds = provider.getHeaderIdsForTask(tasks as TaskResults);
+
+    expect(headerIds).toEqual(['A', 'B', 'M', 'X']);
+  });
+
+  test('expects to handle empty task results', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const filtered = provider.filter([] as TaskResults);
+
+    expect(filtered).toEqual([] as TaskResults);
+  });
+
+  test('expects to handle task results with different contest types', () => {
+    const provider = new AALCProvider(ContestType.AALC);
+    const mockMixedTasks = [
+      { contest_id: 'abc123', task_id: 'abc123_a', task_table_index: 'A' },
+      { contest_id: 'practice2', task_id: 'practice2_a', task_table_index: 'A' },
+      { contest_id: 'game-24', task_id: 'game_a', task_table_index: 'A' },
+    ];
+    const filtered = provider.filter(mockMixedTasks as TaskResults);
+
+    expect(filtered).toEqual([] as TaskResults);
+  });
+});
diff --git a/src/features/tasks/utils/contest-table/aalc_provider.ts b/src/features/tasks/utils/contest-table/aalc_provider.ts
new file mode 100644
index 000000000..29dc72046
--- /dev/null
+++ b/src/features/tasks/utils/contest-table/aalc_provider.ts
@@ -0,0 +1,42 @@
+import {
+  type ContestTableMetaData,
+  type ContestTableDisplayConfig,
+} from '$features/tasks/types/contest-table/contest_table_provider';
+import type { TaskResult } from '$lib/types/task';
+
+import { classifyContest } from '$lib/contests';
+
+import { ContestTableProviderBase } from './contest_table_provider_base';
+
+export class AALCProvider extends ContestTableProviderBase {
+  protected setFilterCondition(): (taskResult: TaskResult) => boolean {
+    return (taskResult: TaskResult) => {
+      if (classifyContest(taskResult.contest_id) !== this.contestType) {
+        return false;
+      }
+
+      return taskResult.contest_id === 'aalc001';
+    };
+  }
+
+  getMetadata(): ContestTableMetaData {
+    return {
+      title: "AAL Contest 001: Let's use segtree!",
+      abbreviationName: 'aalc001',
+    };
+  }
+
+  getDisplayConfig(): ContestTableDisplayConfig {
+    return {
+      isShownHeader: false,
+      isShownRoundLabel: false,
+      roundLabelWidth: '', // No specific width for task index in AAL Contest 001
+      tableBodyCellsWidth: 'w-1/2 xs:w-1/3 sm:w-1/4 md:w-1/5 lg:w-1/6 2xl:w-1/7 px-1 py-2',
+      isShownTaskIndex: true,
+    };
+  }
+
+  getContestRoundLabel(_contestId: string): string {
+    return '';
+  }
+}
diff --git a/src/features/tasks/utils/contest-table/contest_table_provider_groups.test.ts b/src/features/tasks/utils/contest-table/contest_table_provider_groups.test.ts
index 0c6d0c6f1..fd503cce1 100644
--- a/src/features/tasks/utils/contest-table/contest_table_provider_groups.test.ts
+++ b/src/features/tasks/utils/contest-table/contest_table_provider_groups.test.ts
@@ -168,7 +168,7 @@ describe('prepareContestProviderPresets', () => {
       }
     });
 
-    test('dps registers EDPC, TDPC, NDPC, FPS 24, and Game 24 providers', () => {
+    test('dps registers EDPC, TDPC, NDPC, FPS 24, Game 24, and AAL Contest 001 providers', () => {
       const group = presets.dps();
 
       expect(group.getGroupName()).toBe('xDPC・x 24 題');
@@ -176,7 +176,7 @@ describe('prepareContestProviderPresets', () => {
         buttonLabel: 'xDPC・x 24 題',
         ariaLabel: 'xDPC and x 24 contests',
       });
-      expect(group.getSize()).toBe(5);
+      expect(group.getSize()).toBe(6);
 
       const contestTypes = [
         ContestType.EDPC,
@@ -184,6 +184,7 @@ describe('prepareContestProviderPresets', () => {
         ContestType.NDPC,
         ContestType.FPS_24,
         ContestType.GAME_24,
+        ContestType.AALC,
       ];
 
       for (const contestType of contestTypes) {
diff --git a/src/features/tasks/utils/contest-table/contest_table_provider_groups.ts b/src/features/tasks/utils/contest-table/contest_table_provider_groups.ts
index f1733a393..cd5478b23 100644
--- a/src/features/tasks/utils/contest-table/contest_table_provider_groups.ts
+++ b/src/features/tasks/utils/contest-table/contest_table_provider_groups.ts
@@ -26,6 +26,7 @@ import { MathAndAlgorithmProvider } from './math_and_algorithm_provider';
 import { EDPCProvider, TDPCProvider, NDPCProvider } from './dp_providers';
 import { FPS24Provider } from './fps24_provider';
 import { Game24Provider } from './game24_provider';
+import { AALCProvider } from './aalc_provider';
 import { ACLPracticeProvider, ACLBeginnerProvider, ACLProvider } from './acl_providers';
 import {
   JOIFirstQualRoundProvider,
@@ -240,7 +241,7 @@ export const prepareContestProviderPresets = () => {
       }).addProvider(new MathAndAlgorithmProvider(ContestType.MATH_AND_ALGORITHM)),
 
     /**
-     * DP group (EDPC, TDPC, NDPC, FPS 24, and Game 24)
+     * DP group (EDPC, TDPC, NDPC, FPS 24, Game 24, and AAL Contest 001)
      */
     dps: () =>
       new ContestTableProviderGroup(`xDPC・x 24 題`, {
@@ -252,6 +253,7 @@ export const prepareContestProviderPresets = () => {
         new NDPCProvider(ContestType.NDPC),
         new FPS24Provider(ContestType.FPS_24),
         new Game24Provider(ContestType.GAME_24),
+        new AALCProvider(ContestType.AALC),
       ),
 
     /**
diff --git a/src/lib/contests/fixtures/contest_name_labels.ts b/src/lib/contests/fixtures/contest_name_labels.ts
index 5b32407d7..bc4560b5f 100644
--- a/src/lib/contests/fixtures/contest_name_labels.ts
+++ b/src/lib/contests/fixtures/contest_name_labels.ts
@@ -146,6 +146,13 @@ export const game24 = [
   }),
 ];
 
+export const aalc001 = [
+  createTestCaseForContestNameLabel('AAL Contest 001')({
+    contestId: 'aalc001',
+    expected: "AAL Contest 001: Let's use segtree!",
+  }),
+];
+
 export const aojCourses = [
   createTestCaseForContestNameLabel('AOJ, ITP1')({
     contestId: 'ITP1',
diff --git a/src/lib/contests/fixtures/contest_type.ts b/src/lib/contests/fixtures/contest_type.ts
index c8b3670a0..051e5effa 100644
--- a/src/lib/contests/fixtures/contest_type.ts
+++ b/src/lib/contests/fixtures/contest_type.ts
@@ -177,6 +177,13 @@ export const game24 = [
   }),
 ];
 
+export const aalc001 = [
+  createTestCaseForContestType('AAL Contest 001')({
+    contestId: 'aalc001',
+    expected: ContestType.AALC,
+  }),
+];
+
 const arcContestIds = [
   'arc001',
   'arc002',
diff --git a/src/lib/contests/types/contest.ts b/src/lib/contests/types/contest.ts
index 98200fff5..66d49ed9e 100644
--- a/src/lib/contests/types/contest.ts
+++ b/src/lib/contests/types/contest.ts
@@ -49,6 +49,7 @@ export const ContestType: { [key in ContestTypeOrigin]: key } = {
   UNIVERSITY: 'UNIVERSITY', // University Programming Contests in AtCoder (e.g., UTPC)
   FPS_24: 'FPS_24', // 24 Problems on Formal Power Series
   GAME_24: 'GAME_24', // 24 Problems on Combinatorial Games
+  AALC: 'AALC', // AAL Contest 001: Let's use segtree!
   ATCODER_MAIN_OFFICIAL_ONSITE: 'ATCODER_MAIN_OFFICIAL_ONSITE', // AtCoder World Tour Finals (official onsite finals)
   OTHERS: 'OTHERS', // AtCoder (その他)
   AOJ_COURSES: 'AOJ_COURSES', // AIZU ONLINE JUDGE Courses
diff --git a/src/lib/contests/utils/classification.test.ts b/src/lib/contests/utils/classification.test.ts
index 2dd2e0d4e..878545c48 100644
--- a/src/lib/contests/utils/classification.test.ts
+++ b/src/lib/contests/utils/classification.test.ts
@@ -120,6 +120,14 @@ describe('classify contest', () => {
       });
     });
 
+    describe('when contest_id is aalc001', () => {
+      TestCasesForContestType.aalc001.forEach(({ name, value }) => {
+        runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestType) => {
+          expect(classifyContest(contestId)).toEqual(expected);
+        });
+      });
+    });
+
     describe('when contest_id contains arc', () => {
       TestCasesForContestType.arc.forEach(({ name, value }) => {
         runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestType) => {
diff --git a/src/lib/contests/utils/classification.ts b/src/lib/contests/utils/classification.ts
index e4eb58ab0..e409b1743 100644
--- a/src/lib/contests/utils/classification.ts
+++ b/src/lib/contests/utils/classification.ts
@@ -32,6 +32,7 @@ const CONTEST_TYPES_BY_ID: ReadonlyMap<string, ContestType> = new Map([
   ['math-and-algorithm', ContestType.MATH_AND_ALGORITHM],
   ['fps-24', ContestType.FPS_24],
   ['game-24', ContestType.GAME_24],
+  ['aalc001', ContestType.AALC],
 ]);
 
 type ClassificationRule = {
diff --git a/src/lib/contests/utils/labels/index.test.ts b/src/lib/contests/utils/labels/index.test.ts
index c6fd1856e..8acc9d8b0 100644
--- a/src/lib/contests/utils/labels/index.test.ts
+++ b/src/lib/contests/utils/labels/index.test.ts
@@ -106,6 +106,14 @@ describe('get contest name label', () => {
       });
     });
 
+    describe('when contest_id is aalc001', () => {
+      TestCasesForContestNameLabel.aalc001.forEach(({ name, value }) => {
+        runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
+          expect(getContestNameLabel(contestId)).toEqual(expected);
+        });
+      });
+    });
+
     describe('when contest_id contains awc', () => {
       TestCasesForContestNameLabel.awc.forEach(({ name, value }) => {
         runTests(`${name}`, [value], ({ contestId, expected }: TestCaseForContestNameLabel) => {
diff --git a/src/lib/contests/utils/labels/index.ts b/src/lib/contests/utils/labels/index.ts
index 4f04ccd94..09be766a3 100644
--- a/src/lib/contests/utils/labels/index.ts
+++ b/src/lib/contests/utils/labels/index.ts
@@ -35,6 +35,7 @@ export const LABEL_GENERATORS: ReadonlyMap<ContestType, LabelGenerator> = new Ma
   [ContestType.MATH_AND_ALGORITHM, () => 'アルゴリズムと数学'],
   [ContestType.FPS_24, () => 'FPS 24 題'],
   [ContestType.GAME_24, () => '組合せゲーム 24 題'],
+  [ContestType.AALC, () => "AAL Contest 001: Let's use segtree!"],
   [ContestType.ATCODER_MAIN_OFFICIAL_ONSITE, (id) => getWorldTourFinalsLabel(id)],
   [ContestType.UNIVERSITY, (id) => getAtCoderUniversityContestLabel(id)],
   [ContestType.OTHERS, generateOthersLabel],
diff --git a/src/lib/contests/utils/priority.test.ts b/src/lib/contests/utils/priority.test.ts
index 8782099f1..2e088f0dc 100644
--- a/src/lib/contests/utils/priority.test.ts
+++ b/src/lib/contests/utils/priority.test.ts
@@ -128,5 +128,9 @@ describe('contest type priorities', () => {
     test('ranks GAME_24 directly below FPS_24', () => {
       expect(priorityOf(ContestType.GAME_24)).toBe(priorityOf(ContestType.FPS_24) + 1);
     });
+
+    test('ranks AALC directly below GAME_24', () => {
+      expect(priorityOf(ContestType.AALC)).toBe(priorityOf(ContestType.GAME_24) + 1);
+    });
   });
 });
diff --git a/src/lib/contests/utils/priority.ts b/src/lib/contests/utils/priority.ts
index 97ce14819..878498b40 100644
--- a/src/lib/contests/utils/priority.ts
+++ b/src/lib/contests/utils/priority.ts
@@ -2,13 +2,13 @@ import { ContestType } from '$lib/contests/types/contest';
 import { classifyContest } from './classification';
 
 /**
- * Contest type priorities (0 = Highest, 27 = Lowest)
+ * Contest type priorities (0 = Highest, 28 = Lowest)
  *
  * Priority assignment rationale:
  * - Educational contests (0-11, 17): ABS, ABC, APG4B and AWC etc.
  * - Contests for genius (12-16): ARC, AGC, and their variants
- * - Special contests (18-22): UNIVERSITY, FPS_24, GAME_24, ATCODER_MAIN_OFFICIAL_ONSITE, OTHERS
- * - External platforms (23-27): AOJ_COURSES, AOJ_PCK, AOJ_ICPC, AOJ_JAG, AOJ_UNIVERSITY
+ * - Special contests (18-23): UNIVERSITY, FPS_24, GAME_24, AALC, ATCODER_MAIN_OFFICIAL_ONSITE, OTHERS
+ * - External platforms (24-28): AOJ_COURSES, AOJ_PCK, AOJ_ICPC, AOJ_JAG, AOJ_UNIVERSITY
  *
  * @remarks
  * HACK: The priorities for ARC, AGC, UNIVERSITY, AOJ_COURSES, and AOJ_PCK are temporary
@@ -39,13 +39,14 @@ export const contestTypePriorities: Map<ContestType, number> = new Map([
   [ContestType.UNIVERSITY, 18],
   [ContestType.FPS_24, 19],
   [ContestType.GAME_24, 20],
-  [ContestType.ATCODER_MAIN_OFFICIAL_ONSITE, 21],
-  [ContestType.OTHERS, 22], // AtCoder (その他)
-  [ContestType.AOJ_COURSES, 23],
-  [ContestType.AOJ_PCK, 24],
-  [ContestType.AOJ_ICPC, 25],
-  [ContestType.AOJ_JAG, 26],
-  [ContestType.AOJ_UNIVERSITY, 27],
+  [ContestType.AALC, 21],
+  [ContestType.ATCODER_MAIN_OFFICIAL_ONSITE, 22],
+  [ContestType.OTHERS, 23], // AtCoder (その他)
+  [ContestType.AOJ_COURSES, 24],
+  [ContestType.AOJ_PCK, 25],
+  [ContestType.AOJ_ICPC, 26],
+  [ContestType.AOJ_JAG, 27],
+  [ContestType.AOJ_UNIVERSITY, 28],
 ]);
 
 /** Priority given to a contest_id that no classification rule matches, so it sorts last. */