Merge pull request #24 from Ryoga-exe/zig-0.15.1

Ryoga-exe · web-flow · commit 42abb19c6d33 · 2025-08-30T17:49:21.000+09:00
Update for Zig 0.15.1
diff --git a/build.zig.zon b/build.zig.zon
@@ -1,7 +1,7 @@
 .{
     .name = .ac_library,
     .version = "0.3.0",
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.15.1",
     .fingerprint = 0x8ab1cf135fb49dc,
     .paths = .{
         "src",
diff --git a/src/internal_csr.zig b/src/internal_csr.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
 
 pub fn Csr(comptime E: type) type {
     return struct {
@@ -9,15 +10,15 @@ pub fn Csr(comptime E: type) type {
         elist: []E,
         allocator: Allocator,
 
-        pub fn init(allocator: Allocator, n: usize, edges: std.ArrayList(struct { usize, E }), initialValue: E) !Self {
+        pub fn init(allocator: Allocator, n: usize, edges: []struct { usize, E }, initialValue: E) !Self {
             const self = Self{
                 .start = try allocator.alloc(usize, n + 1),
-                .elist = try allocator.alloc(E, edges.items.len),
+                .elist = try allocator.alloc(E, edges.len),
                 .allocator = allocator,
             };
             @memset(self.start, 0);
             @memset(self.elist, initialValue);
-            for (edges.items) |e| {
+            for (edges) |e| {
                 self.start[e.@"0" + 1] += 1;
             }
             for (1..n + 1) |i| {
@@ -26,7 +27,7 @@ pub fn Csr(comptime E: type) type {
             var counter = try allocator.alloc(usize, n + 1);
             defer allocator.free(counter);
             @memcpy(counter, self.start);
-            for (edges.items) |e| {
+            for (edges) |e| {
                 self.elist[counter[e.@"0"]] = e.@"1";
                 counter[e.@"0"] += 1;
             }
diff --git a/src/internal_queue.zig b/src/internal_queue.zig
@@ -14,7 +14,7 @@ pub fn SimpleQueue(comptime T: type) type {
         pub fn init(allocator: Allocator) Self {
             return Self{
                 .allocator = allocator,
-                .payload = .init(allocator),
+                .payload = .empty,
                 .pos = 0,
             };
         }
@@ -28,7 +28,7 @@ pub fn SimpleQueue(comptime T: type) type {
         }
 
         pub fn deinit(self: *Self) void {
-            self.payload.deinit();
+            self.payload.deinit(self.allocator);
         }
 
         pub fn size(self: Self) usize {
@@ -40,7 +40,7 @@ pub fn SimpleQueue(comptime T: type) type {
         }
 
         pub fn push(self: *Self, t: T) Allocator.Error!void {
-            return self.payload.append(t);
+            return self.payload.append(self.allocator, t);
         }
 
         pub fn pushAssumeCapacity(self: *Self, t: T) void {
@@ -55,7 +55,7 @@ pub fn SimpleQueue(comptime T: type) type {
         }
 
         pub fn clearAndFree(self: *Self) void {
-            self.payload.clearAndFree();
+            self.payload.clearAndFree(self.allocator);
             self.pos = 0;
         }
 
diff --git a/src/internal_scc.zig b/src/internal_scc.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 const Csr = @import("internal_csr.zig").Csr;
 const Groups = @import("internal_groups.zig");
 const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
 
 const SccGraph = @This();
 
@@ -12,39 +13,39 @@ const Env = struct {
     g: Csr(Edge),
     now_ord: usize,
     group_num: usize,
-    visited: std.ArrayList(usize),
+    visited: ArrayList(usize),
     low: []usize,
     ord: []?usize,
     ids: []usize,
 };
 
 n: usize,
-edges: std.ArrayList(struct { usize, Edge }),
+edges: ArrayList(struct { usize, Edge }),
 allocator: Allocator,
 
 pub fn init(allocator: Allocator, n: usize) SccGraph {
     const self = SccGraph{
         .n = n,
-        .edges = std.ArrayList(struct { usize, Edge }).init(allocator),
+        .edges = .empty,
         .allocator = allocator,
     };
     return self;
 }
 pub fn deinit(self: *SccGraph) void {
-    self.edges.deinit();
+    self.edges.deinit(self.allocator);
 }
 pub fn numVertices(self: SccGraph) usize {
     return self.n;
 }
 pub fn addEdge(self: *SccGraph, from: usize, to: usize) !void {
-    try self.edges.append(.{ from, Edge{ .to = to } });
+    try self.edges.append(self.allocator, .{ from, Edge{ .to = to } });
 }
 pub fn sccIds(self: SccGraph) !struct { usize, []usize } {
     var env = Env{
-        .g = try Csr(Edge).init(self.allocator, self.n, self.edges, Edge{ .to = 0 }),
+        .g = try .init(self.allocator, self.n, self.edges.items, Edge{ .to = 0 }),
         .now_ord = 0,
         .group_num = 0,
-        .visited = try std.ArrayList(usize).initCapacity(self.allocator, self.n),
+        .visited = try .initCapacity(self.allocator, self.n),
         .low = try self.allocator.alloc(usize, self.n),
         .ord = try self.allocator.alloc(?usize, self.n),
         .ids = try self.allocator.alloc(usize, self.n),
@@ -56,15 +57,15 @@ pub fn sccIds(self: SccGraph) !struct { usize, []usize } {
 
     defer {
         env.g.deinit();
-        env.visited.deinit();
+        env.visited.deinit(self.allocator);
         self.allocator.free(env.low);
         self.allocator.free(env.ord);
         self.allocator.free(env.ids);
     }
 
     for (0..self.n) |i| {
         if (env.ord[i] == null) {
-            try dfs(i, self.n, &env);
+            try dfs(self.allocator, i, self.n, &env);
         }
     }
     for (0..self.n) |i| {
@@ -82,20 +83,20 @@ pub fn scc(self: SccGraph) !Groups {
     for (0..self.n) |i| {
         group_index[i] = ids[i];
     }
-    return try Groups.init(self.allocator, group_num, group_index);
+    return try .init(self.allocator, group_num, group_index);
 }
-fn dfs(v: usize, n: usize, env: *Env) !void {
+fn dfs(allocator: Allocator, v: usize, n: usize, env: *Env) !void {
     env.low[v] = env.now_ord;
     env.ord[v] = env.now_ord;
     env.now_ord += 1;
-    try env.visited.append(v);
+    try env.visited.append(allocator, v);
 
     for (env.g.start[v]..env.g.start[v + 1]) |i| {
         const to = env.g.elist[i].to;
         if (env.ord[to]) |ord| {
             env.low[v] = @min(env.low[v], ord);
         } else {
-            try dfs(to, n, env);
+            try dfs(allocator, to, n, env);
             env.low[v] = @min(env.low[v], env.low[to]);
         }
     }
diff --git a/src/lib.zig b/src/lib.zig
@@ -17,8 +17,20 @@ pub const Modint998244353 = @import("modint.zig").Modint998244353;
 pub const DynamicModint = @import("modint.zig").DynamicModint;
 pub const Modint = @import("modint.zig").Modint;
 
-pub usingnamespace @import("math.zig");
-pub usingnamespace @import("string.zig");
+pub const math = @import("math.zig");
+pub const powMod = math.powMod;
+pub const invMod = math.invMod;
+pub const crt = math.crt;
+pub const floorSum = math.floorSum;
+
+pub const string = @import("string.zig");
+pub const suffixArrayManual = string.suffixArrayManual;
+pub const suffixArrayArbitrary = string.suffixArrayArbitrary;
+pub const suffixArray = string.suffixArray;
+pub const lcpArrayArbitrary = string.lcpArrayArbitrary;
+pub const lcpArray = string.lcpArray;
+pub const zAlgorithmArbitrary = string.zAlgorithmArbitrary;
+pub const zAlgorithm = string.zAlgorithm;
 
 test {
     std.testing.refAllDecls(@This());
diff --git a/src/maxflow.zig b/src/maxflow.zig
@@ -73,21 +73,21 @@ pub fn MfGraph(comptime Cap: type) type {
         pub fn init(allocator: Allocator, n: usize) Allocator.Error!Self {
             const g = try allocator.alloc(Graph, n);
             for (g) |*item| {
-                item.* = .init(allocator);
+                item.* = .empty;
             }
             return Self{
                 .allocator = allocator,
                 .n = n,
-                .pos = .init(allocator),
+                .pos = .empty,
                 .g = g,
             };
         }
 
         /// Release all allocated memory.
-        pub fn deinit(self: Self) void {
-            self.pos.deinit();
-            for (self.g) |item| {
-                item.deinit();
+        pub fn deinit(self: *Self) void {
+            self.pos.deinit(self.allocator);
+            for (self.g) |*item| {
+                item.deinit(self.allocator);
             }
             self.allocator.free(self.g);
         }
@@ -114,11 +114,11 @@ pub fn MfGraph(comptime Cap: type) type {
             assert(to < self.n);
             assert(0 <= cap);
             const m = self.pos.items.len;
-            try self.pos.append(.{ from, self.g[from].items.len });
+            try self.pos.append(self.allocator, .{ from, self.g[from].items.len });
             const rev = self.g[to].items.len + @intFromBool(from == to);
-            try self.g[from].append(InternalEdge{ .to = to, .rev = rev, .cap = cap });
+            try self.g[from].append(self.allocator, InternalEdge{ .to = to, .rev = rev, .cap = cap });
             const rev2 = self.g[from].items.len - 1;
-            try self.g[to].append(InternalEdge{
+            try self.g[to].append(self.allocator, InternalEdge{
                 .to = from,
                 .rev = rev2,
                 .cap = 0,
diff --git a/src/mincostflow.zig b/src/mincostflow.zig
@@ -71,14 +71,14 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
         pub fn init(allocator: Allocator, n: usize) Self {
             return Self{
                 .allocator = allocator,
-                .edges = .init(allocator),
+                .edges = .empty,
                 .n = n,
             };
         }
 
         /// Release all allocated memory.
         pub fn deinit(self: *Self) void {
-            self.edges.deinit();
+            self.edges.deinit(self.allocator);
         }
 
         /// Adds an edge oriented from `from` to `to` with capacity `cap` and cost `cost`.
@@ -105,7 +105,7 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
             assert(0 <= cap);
             assert(0 <= cost);
             const m = self.edges.items.len;
-            try self.edges.append(Edge{
+            try self.edges.append(self.allocator, Edge{
                 .from = from,
                 .to = to,
                 .cap = cap,
@@ -264,7 +264,7 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                 defer allocator.free(redge_idx);
 
                 var elist = try ArrayList(struct { usize, InsideEdge }).initCapacity(allocator, 2 * m);
-                defer elist.deinit();
+                defer elist.deinit(self.allocator);
                 for (0..m) |i| {
                     const e = self.edges.items[i];
                     edge_idx[i] = degree[e.from];
@@ -290,7 +290,7 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                         },
                     });
                 }
-                var g = try internal.Csr(InsideEdge).init(allocator, n, elist, .zero);
+                var g = try internal.Csr(InsideEdge).init(allocator, n, elist.items, .zero);
                 for (0..m) |i| {
                     const e = self.edges.items[i];
                     edge_idx[i] += g.start[e.from];
@@ -315,8 +315,8 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                 var flow_current: Cap = 0;
                 var cost_current: Cost = 0;
                 var prev_cost_per_flow: Cost = -1;
-                var result = ArrayList(CapCostPair).init(allocator);
-                try result.append(CapCostPair{ 0, 0 });
+                var result: ArrayList(CapCostPair) = .empty;
+                try result.append(self.allocator, CapCostPair{ 0, 0 });
                 while (flow_current < flow_limit) {
                     if (!try self.refineDual(s, t, g, dual_dist, vis, prev_e)) {
                         break;
@@ -338,11 +338,11 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                     if (prev_cost_per_flow == d) {
                         _ = result.pop();
                     }
-                    try result.append(CapCostPair{ flow_current, cost_current });
+                    try result.append(self.allocator, CapCostPair{ flow_current, cost_current });
                     prev_cost_per_flow = d;
                 }
 
-                break :blk try result.toOwnedSlice();
+                break :blk try result.toOwnedSlice(self.allocator);
             };
 
             for (0..m) |i| {
@@ -390,13 +390,13 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                     return math.order(a.key, b.key);
                 }
             };
-            var que_min = ArrayList(usize).init(allocator);
-            defer que_min.deinit();
+            var que_min: ArrayList(usize) = .empty;
+            defer que_min.deinit(self.allocator);
             var que = std.PriorityQueue(Q, void, Q.lessThan).init(allocator, {});
             defer que.deinit();
 
             dual[s].@"1" = 0;
-            try que_min.append(s);
+            try que_min.append(self.allocator, s);
             while (que.count() > 0 or que_min.items.len > 0) {
                 const v = que_min.pop() orelse que.remove().to;
                 if (vis[v]) {
@@ -418,7 +418,7 @@ pub fn McfGraph(comptime Cap: type, comptime Cost: type) type {
                         dual[e.to].@"1" = dist_to;
                         prev_e[e.to] = e.rev;
                         if (dist_to == dist_v) {
-                            try que_min.append(e.to);
+                            try que_min.append(self.allocator, e.to);
                         } else {
                             try que.add(Q{ .key = dist_to, .to = e.to });
                         }
diff --git a/src/string.zig b/src/string.zig
@@ -2,6 +2,7 @@
 
 const std = @import("std");
 const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
 const assert = std.debug.assert;
 
 fn saNaive(comptime T: type, allocator: Allocator, s: []const T) Allocator.Error![]usize {
@@ -214,8 +215,8 @@ fn saIs(comptime threshold: Threshold, allocator: Allocator, s: []const usize, u
             m += 1;
         }
     }
-    var lms = try std.ArrayList(usize).initCapacity(allocator, m);
-    defer lms.deinit();
+    var lms = try ArrayList(usize).initCapacity(allocator, m);
+    defer lms.deinit(allocator);
     for (1..n) |i| {
         if (!ls[i - 1] and ls[i]) {
             lms.appendAssumeCapacity(i);
@@ -225,8 +226,8 @@ fn saIs(comptime threshold: Threshold, allocator: Allocator, s: []const usize, u
     try induce.f(context, sa, lms.items);
 
     if (m > 0) {
-        var sorted_lms = try std.ArrayList(usize).initCapacity(allocator, m);
-        defer sorted_lms.deinit();
+        var sorted_lms = try ArrayList(usize).initCapacity(allocator, m);
+        defer sorted_lms.deinit(allocator);
         for (sa) |v| {
             if (lms_map[v - 1] != 0) {
                 sorted_lms.appendAssumeCapacity(v - 1);

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ pub fn SimpleQueue(comptime T: type) type {`
`14`	`14`	`pub fn init(allocator: Allocator) Self {`
`15`	`15`	`return Self{`
`16`	`16`	`.allocator = allocator,`
`17`		`- .payload = .init(allocator),`
	`17`	`+ .payload = .empty,`
`18`	`18`	`.pos = 0,`
`19`	`19`	`};`
`20`	`20`	`}`
`@@ -28,7 +28,7 @@ pub fn SimpleQueue(comptime T: type) type {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`pub fn deinit(self: *Self) void {`
`31`		`- self.payload.deinit();`
	`31`	`+ self.payload.deinit(self.allocator);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`pub fn size(self: Self) usize {`
`@@ -40,7 +40,7 @@ pub fn SimpleQueue(comptime T: type) type {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`pub fn push(self: *Self, t: T) Allocator.Error!void {`
`43`		`- return self.payload.append(t);`
	`43`	`+ return self.payload.append(self.allocator, t);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`pub fn pushAssumeCapacity(self: *Self, t: T) void {`
`@@ -55,7 +55,7 @@ pub fn SimpleQueue(comptime T: type) type {`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`pub fn clearAndFree(self: *Self) void {`
`58`		`- self.payload.clearAndFree();`
	`58`	`+ self.payload.clearAndFree(self.allocator);`
`59`	`59`	`self.pos = 0;`
`60`	`60`	`}`
`61`	`61`