santisify Site

Go并发编程

Wed, 01 Jul 2026 22:00:00 GMT

并发模型(CSP理论、Goroutine轻量级线程)

基础概念

并发: 多个任务在同一时间段内交替执行, 但不一定同时执行, 也就是任务之间的切换是有序的, 任务之间是有依赖关系的.

并行: 多个任务在同一时刻同时执行

CSP理论:

核心思想: 不要通过共享内存来通信，而要通过通信来共享内存
组成要素: Process (进程\协程)、Channel (通道)

应用场景

Goroutine：

高并发Web服务器：每个请求一个Goroutine
数据处理流水线：多个处理阶段并行执行
实时消息推送：WebSocket连接管理
定时任务调度：后台定时执行任务
并发爬虫：同时抓取多个网页

传统多线程与Goroutine的区别：

| 特性 | 传统线程 | Goroutine | |------|----------|-----------| | 创建成本 | 1-2MB | 2KB | | 创建速度 | 慢 | 快 | | 调度方式 | 操作系统调度 | Go运行时调度 | | 上下文切换 | 完整线程切换 | 用户态轻量切换 |

通道(Channel)

Channel是Go语言中各个并发执行体间的通信机制，是类型相关的管道，用于在goroutine之间传递数据和同步执行。

不要通过共享内存来通信，而应通过通信来共享内存

// 创建channel
ch1 := make(chan int)        // 无缓冲channel 
ch2 := make(chan int, 10)   // 有缓冲channel，容量10

// 操作
ch1 <- 42    // 发送数据到channel
value := <-ch1 // 从channel接收数据
close(ch1)   // 关闭channel

// 特殊用法
value, ok := <-ch1 // 检查channel是否关闭

缓冲区区别：

无缓冲channel：同步通信，发送和接收必须同时准备好
有缓冲channel：异步通信，缓冲区满时发送阻塞，空时接收阻塞

package main

import (
    "fmt"
    "math/rand"
    "time"
)

type Order struct {
    ID        int
    UserID    string
    Amount    float64
    Status    string
    CreatedAt time.Time
}

func orderProducer(orderChan chan<- Order, numOrders int) {
    for i := 1; i <= numOrders; i++ {
        order := Order{
            ID:        i,
            UserID:    fmt.Sprintf("user%d", rand.Intn(100)),
            Amount:    rand.Float64() * 1000,
            Status:    "pending",
            CreatedAt: time.Now(),
        }
        orderChan <- order
        fmt.Printf("生成订单: ID=%d, 用户=%s, 金额=¥%.2f\n", 
            order.ID, order.UserID, order.Amount)
        time.Sleep(time.Millisecond * 100) // 模拟生成间隔
    }
    close(orderChan)
}

func orderProcessor(orderChan <-chan Order, resultChan chan<- Order) {
    for order := range orderChan {
        // 模拟订单处理逻辑
        processingTime := time.Duration(rand.Intn(300)) * time.Millisecond
        time.Sleep(processingTime)
        
        // 更新订单状态
        if order.Amount > 500 {
            order.Status = "verified" // 大额订单需要验证
        } else {
            order.Status = "completed"
        }
        
        resultChan <- order
    }
	time.Sleep(time.Second * 1)
	close(resultChan)
}

func orderResultCollector(resultChan <-chan Order, done chan<- bool) {
    processedCount := 0
    for order := range resultChan {
        processedCount++
        fmt.Printf("处理完成: 订单ID=%d, 状态=%s, 金额=¥%.2f\n", 
            order.ID, order.Status, order.Amount)
    }
    fmt.Printf("所有订单处理完成! 总计: %d 个订单\n", processedCount)
    done <- true
}

func main() {
    rand.Seed(time.Now().UnixNano())
    
    // 创建管道
    orderChan := make(chan Order, 10)
    resultChan := make(chan Order, 10)
    done := make(chan bool)
    
    // 启动订单生成器
    go orderProducer(orderChan, 20)
    
    // 启动多个订单处理器（工人）
    for i := 1; i <= 3; i++ {
        go orderProcessor(orderChan, resultChan)
    }
    
    // 启动结果收集器
    go orderResultCollector(resultChan, done)
    
    // 等待所有处理完成
    <-done
}

select多路复用：同时等待多个channel操作。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 1. select多路复用
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "来自ch1"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "来自ch2"
    }()
    
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("收到:", msg1)
        case msg2 := <-ch2:
            fmt.Println("收到:", msg2)
        case <-time.After(3 * time.Second): // 超时控制
            fmt.Println("超时!")
            return
        }
    }
    
    // 2. 定时器与Ticker
    ticker := time.NewTicker(500 * time.Millisecond)
    done := make(chan bool)
    
    go func() {
        for {
            select {
            case <-done:
                return
            case t := <-ticker.C:
                fmt.Println("定时触发 at", t.Format("15:04:05"))
            }
        }
    }()
    
    time.Sleep(2 * time.Second)
    ticker.Stop()
    done <- true
    fmt.Println("Ticker停止")
    
    // 3. 工作池模式
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    
    // 发送5个任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    
    // 收集结果
    for i:=0; i<=5; i++ {
		value := <-results
        fmt.Printf("Worker 处理结果 %d\n", value)
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d 处理任务 %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

同步原语（sync.Mutex互斥锁、sync.WaitGroup等待组、sync.RWMutex读写锁）

为什么需要同步原语？ 在并发编程中，多个goroutine同时访问共享资源时会产生竞态条件，导致数据不一致。

sync.Mutex（互斥锁）

保证同一时间只有一个goroutine能访问共享资源
两个方法：Lock() 和 Unlock()
使用后必须释放，否则会导致死锁

sync.RWMutex（读写锁）

允许多个读操作或一个写操作
读锁：RLock() / RUnlock()（共享锁）
写锁：Lock() / Unlock()（互斥锁）
适合"读多写少"的场景

sync.WaitGroup（等待组）

等待一组goroutine完成工作
三个方法：Add()、Done()、Wait()
用于协调多个goroutine的执行顺序

var wg sync.WaitGroup

func main() {
    for i := 0; i < 3; i++ {
        wg.Add(1)        // 计数器+1
        go worker(i)
    }
    wg.Wait()           // 等待所有goroutine完成
}

package main

import (
    "fmt"
    "sync"
    "time"
)

type Inventory struct {
    stock    int              // 库存数量
    rwMutex  sync.RWMutex     // 保护库存
}

// 查询库存（使用读写锁的读锁）
func (inv *Inventory) getStock() int {
    inv.rwMutex.RLock()
    defer inv.rwMutex.RUnlock()
    return inv.stock
}

// 扣减库存（使用互斥锁和读写锁的写锁）
func (inv *Inventory) deductStock(userID int, quantity int) bool {
    // 先检查库存（读锁）
    inv.rwMutex.Lock()
    defer inv.rwMutex.Unlock()
	
    // 检查，防止超卖
    if inv.stock < quantity {
        fmt.Printf("用户%d: 库存不足，扣减失败\n", userID)
        return false
    }
    
    inv.stock -= quantity
    fmt.Printf("用户%d: 成功购买%d件，剩余库存%d\n", userID, quantity, inv.stock)
    return true
}

func main() {
    inventory := &Inventory{stock: 10} // 初始库存10件
    
    var wg sync.WaitGroup
    
    // 模拟100个用户同时抢购
    for i := 1; i <= 100; i++ {
        wg.Add(1)
        go func(userID int) {
            defer wg.Done()
            inventory.deductStock(userID, 1)
        }(i)
    }
    
    wg.Wait()
    fmt.Printf("最终库存: %d\n", inventory.getStock())
}

原子操作替代简单锁：

import "sync/atomic"

type Counter struct {
    value int64
}

func (c *Counter) Increment() {
    atomic.AddInt64(&c.value, 1) // 比mutex性能更好
}

func (c *Counter) Decrement() {
    atomic.AddInt64(&c.value, -1) 
}

func (c *Counter) Value() int64 {
    return atomic.LoadInt64(&c.value)
}

func main() {
	var counter Counter
    var wg sync.WaitGroup
  
    // 模拟100个用户同时点赞
    for i := 1; i <= 100; i++ {
      wg.Add(1)
      go func() {
          defer wg.Done()
          counter.Increment()
      }()
    }

    // 模拟10个用户取消点赞
    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Decrement()
        }()
    }
  
    wg.Wait()
}

并发模式（生产者-消费者、扇入/扇出、Pipeline）

生产者-消费者模式

生产者-消费者模式是并发编程中最经典的模式之一，解决生产者和消费者速度不匹配的问题。
就像食堂阿姨打饭和同学们吃饭，赚钱和花钱的关系是一样的。

扇入/扇出模式：

扇出：一个channel分发给多个goroutine处理（一产多消）
扇入：多个channel合并到一个channel（多产一消）

Pipeline模式：将复杂任务分解为多个处理阶段，每个阶段通过channel连接，形成处理流水线。

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

// 订单结构
type Order struct {
    ID       int
    UserID   int
    Amount   float64
    Status   string
    CreateAt time.Time
}

// 1. 生产者-消费者：订单生成与处理
func orderProducer(orderCh chan<- Order, count int) {
    defer close(orderCh)
    for i := 1; i <= count; i++ {
        order := Order{
            ID:       i,
            UserID:   rand.Intn(1000) + 1,
            Amount:   rand.Float64() * 1000,
            Status:   "pending",
            CreateAt: time.Now(),
        }
        fmt.Printf("生成订单: ID=%d, 金额=¥%.2f\n", order.ID, order.Amount)
        orderCh <- order
        time.Sleep(100 * time.Millisecond) // 模拟生成间隔
    }
}

func orderConsumer(orderCh <-chan Order, wg *sync.WaitGroup) {
    defer wg.Done()
    for order := range orderCh {
        // 模拟订单处理
        time.Sleep(200 * time.Millisecond)
        order.Status = "processed"
        fmt.Printf("处理订单: ID=%d, 状态=%s\n", order.ID, order.Status)
    }
}

// 2. 扇出模式：一个订单流分发给多个处理器
func fanOutProcessor(input <-chan Order, workerID int, wg *sync.WaitGroup) {
    defer wg.Done()
    for order := range input {
        // 不同的处理器做不同的处理
        switch workerID {
        case 1:
            // 处理器1：计算折扣
            discount := order.Amount * 0.1
            fmt.Printf("处理器%d计算折扣: 订单%d 优惠¥%.2f\n", 
                workerID, order.ID, discount)
        case 2:
            // 处理器2：发送通知
            fmt.Printf("处理器%d发送通知: 订单%d创建成功\n", 
                workerID, order.ID)
        case 3:
            // 处理器3：记录日志
            fmt.Printf("处理器%d记录日志: 订单%d金额¥%.2f\n", 
                workerID, order.ID, order.Amount)
        }
        time.Sleep(150 * time.Millisecond)
    }
}

// 3. 扇入模式：多个数据源合并
func fanInProducer(producerID int, output chan<- Order) {
    defer fmt.Printf("生产者%d结束\n", producerID)
    for i := 1; i <= 3; i++ {
        order := Order{
            ID:     producerID*100 + i,
            UserID: producerID,
            Amount: float64(producerID*100 + i),
            Status: "new",
        }
        fmt.Printf("生产者%d生成订单: %d\n", producerID, order.ID)
        output <- order
        time.Sleep(time.Duration(producerID) * 100 * time.Millisecond)
    }
}

// 4. Pipeline模式：订单处理流水线
func validationStage(input <-chan Order) <-chan Order {
    output := make(chan Order, 10)
    go func() {
        defer close(output)
        for order := range input {
            // 第一阶段：订单验证
            time.Sleep(50 * time.Millisecond)
            if order.Amount > 0 {
                order.Status = "validated"
                fmt.Printf("验证通过: 订单%d\n", order.ID)
                output <- order
            } else {
                fmt.Printf("验证失败: 订单%d金额异常\n", order.ID)
            }
        }
    }()
    return output
}

func paymentStage(input <-chan Order) <-chan Order {
    output := make(chan Order, 10)
    go func() {
        defer close(output)
        for order := range input {
            // 第二阶段：支付处理
            time.Sleep(100 * time.Millisecond)
            order.Status = "paid"
            fmt.Printf("支付成功: 订单%d\n", order.ID)
            output <- order
        }
    }()
    return output
}

func shippingStage(input <-chan Order) <-chan Order {
    output := make(chan Order, 10)
    go func() {
        defer close(output)
        for order := range input {
            // 第三阶段：发货处理
            time.Sleep(150 * time.Millisecond)
            order.Status = "shipped"
            fmt.Printf("发货完成: 订单%d\n", order.ID)
            output <- order
        }
    }()
    return output
}

func main() {
    rand.Seed(time.Now().UnixNano())
    
    fmt.Println("=== 1. 生产者-消费者模式演示 ===")
    // 创建订单channel
    orderCh := make(chan Order, 5)
    var wg sync.WaitGroup
    
    // 启动消费者
    wg.Add(2)
    go orderConsumer(orderCh, &wg)
    go orderConsumer(orderCh, &wg)
    
    // 启动生产者
    go orderProducer(orderCh, 6)
    
    wg.Wait()
    
    fmt.Println("\n=== 2. 扇出模式演示 ===")
    // 扇出：一个输入，多个处理器
    fanOutCh := make(chan Order, 10)
    var fanOutWg sync.WaitGroup
    
    // 启动3个处理器
    fanOutWg.Add(3)
    for i := 1; i <= 3; i++ {
        go fanOutProcessor(fanOutCh, i, &fanOutWg)
    }
    
    // 生产一些测试数据
    go func() {
        for i := 1; i <= 6; i++ {
            fanOutCh <- Order{ID: i, Amount: float64(i * 100)}
        }
        close(fanOutCh)
    }()
    
    fanOutWg.Wait()
    
    fmt.Println("\n=== 3. 扇入模式演示 ===")
    // 扇入：多个生产者，一个输出
    fanInCh := make(chan Order, 10)
    
    // 启动3个生产者
    for i := 1; i <= 3; i++ {
        go fanInProducer(i, fanInCh)
    }
    
    // 收集结果
    go func() {
        time.Sleep(2 * time.Second)
        close(fanInCh)
    }()
    
    fmt.Println("收集到的订单:")
    for order := range fanInCh {
        fmt.Printf("  订单ID: %d, 金额: ¥%.2f\n", order.ID, order.Amount)
    }
    
    fmt.Println("\n=== 4. Pipeline模式演示 ===")
    // 创建初始输入
    pipelineInput := make(chan Order, 10)
    
    // 构建流水线
    validatedOrders := validationStage(pipelineInput)
    paidOrders := paymentStage(validatedOrders)
    shippedOrders := shippingStage(paidOrders)
    
    // 发送测试订单到流水线
    go func() {
        for i := 1; i <= 3; i++ {
            pipelineInput <- Order{
                ID:     i,
                UserID: i * 10,
                Amount: float64(i * 50),
                Status: "new",
            }
        }
        close(pipelineInput)
    }()
    
    // 收集最终结果
    fmt.Println("流水线处理结果:")
    for order := range shippedOrders {
        fmt.Printf("  完成: 订单%d, 状态: %s\n", order.ID, order.Status)
    }
    
    fmt.Println("\n🎉 所有并发模式演示完成!")
}

带错误处理的并发模式：

package main

import (
    "errors"
    "fmt"
    "sync"
    "time"
)

type Result struct {
    Value int
    Error error
}

// 带错误处理的生产者-消费者
func safeProducer(ch chan<- Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 1; i <= 5; i++ {
        // 模拟偶尔出错
        if i == 3 {
            ch <- Result{Error: errors.New("模拟错误")}
        } else {
            ch <- Result{Value: i}
        }
        time.Sleep(100 * time.Millisecond)
    }
	close(ch)
}

func safeConsumer(ch <-chan Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for result := range ch {
        if result.Error != nil {
            fmt.Printf("处理出错: %v\n", result.Error)
        } else {
            fmt.Printf("处理成功: %d\n", result.Value)
        }
    }
}

func main() {
    fmt.Println("=== 带错误处理的并发 ===")
    
    resultCh := make(chan Result, 5)
    var safeWg sync.WaitGroup
    
    safeWg.Add(2)
    go safeProducer(resultCh, &safeWg)
    go safeConsumer(resultCh, &safeWg)
    
    safeWg.Wait()
}

网络基础（TCP/IP协议、三次握手、端口概念）

核心概念

TCP/IP协议族是互联网通信的基础，就像现实世界的邮政系统一样，负责数据的可靠传输。

TCP/IP四层模型（类比快递系统）：

应用层 - 你的信件内容（HTTP、FTP、SMTP）
传输层 - 快递包装和物流单（TCP、UDP）
网络层 - 地址和路由（IP协议）
网络接口层 - 运输工具（以太网、WiFi）

TCP vs UDP 核心区别：

TCP - 可靠传输，像打电话
- 需要建立连接（三次握手）
- 保证数据顺序和完整性
- 自动重传丢失的数据
- 适合：网页浏览、文件传输、邮件
UDP - 不可靠传输，像发短信
- 无需建立连接
- 不保证数据到达顺序
- 可能丢失数据包
- 适合：视频流、游戏、DNS查询

三次握手详解

TCP连接建立过程 - 就像确认双方都能正常沟通：

为什么需要三次握手？

防止历史连接：避免网络延迟导致的重复连接请求
同步序列号：确保双方都知道对方的起始序号
确认双向可达：证明客户端和服务器都能正常收发数据

端口概念与应用

端口的作用 - 就像公司的分机号，员工号：

80: HTTP - 网页浏览
443: HTTPS - 安全网页
22: SSH - 安全远程登录
53: DNS - 域名解析
3306: MySQL - 数据库
5432: PostgreSQL - 数据库
6379: Redis - 缓存数据库

package main

import (
	"fmt"
	"net"
	"sync"
)

type ChatRoom struct {
	clients map[net.Conn]string
	mutex   sync.RWMutex
}

func NewChatRoom() *ChatRoom {
	return &ChatRoom{
		clients: make(map[net.Conn]string),
	}
}

func (cr *ChatRoom) broadcast(sender net.Conn, msg string) {
	cr.mutex.RLock()
	defer cr.mutex.RUnlock()
	for client, name := range cr.clients {
		if sender == client {
			continue
		}
		client.Write([]byte(name + ": " + msg))
	}
}

func (cr *ChatRoom) handleConnection(conn net.Conn) {
	defer conn.Close()

	conn.Write([]byte("请输入你的昵称："))
	name := make([]byte, 1024)
	n, _ := conn.Read(name)
	cr.mutex.Lock()
	cr.clients[conn] = string(name[:n-1])
	cr.mutex.Unlock()
	username := string(name[:n-1])
	cr.broadcast(conn, fmt.Sprintf("系统: %s 加入了聊天室\n", username))

	for {
		readBuff := make([]byte, 1024)
		n, err := conn.Read(readBuff)
		if err != nil {
			break
		}

		message := string(readBuff[:n])
		if message == "quit\n" {
			break
		}
		cr.broadcast(conn, fmt.Sprintf("%s: %s\n", username, message))
	}
	cr.mutex.Lock()
	delete(cr.clients, conn)
	cr.mutex.Unlock()
	cr.broadcast(conn, fmt.Sprintf("系统: %s 离开了聊天室", username))
}

func main() {
	chatRoom := NewChatRoom()
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}

	defer listener.Close()
	fmt.Println("启动监听成功")
	for {
		conn, _ := listener.Accept()
		go chatRoom.handleConnection(conn)
	}
}

HTTP编程（net/http包、创建HTTP服务器、处理请求与响应）

什么是HTTP？

HTTP（HyperText Transfer Protocol，超文本传输协议）是互联网上应用最为广泛的一种网络协议，用于客户端和服务器之间的通信。

核心特点：

无状态协议：每次请求都是独立的，服务器不保留之前请求的信息
基于请求-响应模型：客户端发起请求，服务器返回响应
应用层协议：建立在TCP/IP协议之上
明文传输：数据不加密（HTTPS是加密版本）

HTTP请求-响应流程

客户端 (浏览器/APP)       服务器 (Web服务)
     |                         |
     | --- HTTP请求  ------->  |
     |                         | 
     | <--- HTTP响应 --------  |
     |                         |

HTTP请求组成

GET /api/students HTTP/1.1          ← 请求行（方法 + URL + 协议版本）
Host: localhost:8080                ← 请求头（元数据）
Content-Type: application/json
Authorization: Bearer token123
                                   ← 空行分隔
{"name": "张三", "age": 20}         ← 请求体（可选，POST/PUT时有）

HTTP方法语义：

GET：获取资源（查）
POST：创建资源（增）
PUT：更新资源（改）
DELETE：删除资源（删）
PATCH：部分更新

HTTP响应组成

HTTP/1.1 200 OK                     ← 状态行（协议版本 + 状态码 + 描述）
Content-Type: application/json      ← 响应头（元数据）
Content-Length: 45
Date: Mon, 23 Oct 2023 08:00:00 GMT
                                   ← 空行分隔
{"id": 1, "name": "张三", "age": 20} ← 响应体（数据内容）

常见状态码：

200 OK：请求成功
201 Created：资源创建成功
400 Bad Request：客户端请求错误
401 Unauthorized：未认证
404 Not Found：资源不存在
500 Internal Server Error：服务器内部错误

net/http包架构

客户端请求
    ↓
http.ServeMux (路由 multiplexer) 
    ↓
http.Handler (处理器接口)
    ↓  
具体处理逻辑 (HandlerFunc或自定义Handler)
    ↓
http.ResponseWriter (写回响应)

核心组件说明

1. 路由 (ServeMux)

负责将不同的URL路径映射到对应的处理器
可以创建多个路由，但通常一个应用使用一个主路由

2. 处理器 (Handler)

// Handler是一个接口，只需要实现一个方法
type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

3. 处理器函数 (HandlerFunc)

// 函数签名，与ServeHTTP方法相同
type HandlerFunc func(ResponseWriter, *Request)

4. 请求对象 (Request)

包含客户端的全部请求信息
方法、URL、请求头、请求体等

5. 响应写入器 (ResponseWriter)

用于构建和发送响应回客户端
可以设置状态码、响应头、写入响应体

package main

import (
	"fmt"
	"net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/students", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add("Content-Type", "application/json")
		if r.Method == http.MethodGet {
			fmt.Fprintf(w, `[{"id" : 1, "name": "张三", "age": 20}]`)
			return
		}
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	})

	http.ListenAndServe(":8080", mux)
}

Websocket

WebSocket是什么？

想象一下你和朋友打电话的场景：

HTTP：像发短信，每次都要建立连接→发送→断开，不能实时对话
WebSocket：像打电话，一次接通后双方可以随时说话，实现真正的实时对话

WebSocket核心特点：

一次握手，长久连接：客户端发起WebSocket请求，服务端同意后建立持久连接
双向通信：服务端可以主动向客户端推送数据，不再需要客户端轮询
低延迟：避免了HTTP每次请求的头部开销和连接建立时间
协议升级：基于HTTP协议升级而来（HTTP 101状态码）

WebSocket握手过程：

客户端请求：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade

服务端响应：
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade

为什么需要gorilla/websocket库？ Go标准库没有提供完整的WebSocket实现，gorilla/websocket是业界最成熟的选择：

处理了WebSocket协议细节
提供了连接管理、消息读写等高级功能
有良好的错误处理和连接状态管理

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

// 创建WebSocket升级器
var upgrader = websocket.Upgrader{
    // 允许所有跨域请求（生产环境应该严格限制）
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func main() {
    // 设置WebSocket路由
    http.HandleFunc("/ws", handleWebSocket)
    
    // 启动静态文件服务（用于提供HTML页面）
    http.Handle("/", http.FileServer(http.Dir("./public")))
    
    fmt.Println("WebSocket服务器启动在 :8080")
    fmt.Println("访问 http://localhost:8080 测试聊天功能")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    // 1. 升级HTTP连接到WebSocket连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("升级WebSocket失败:", err)
        return
    }
    defer conn.Close() // 确保连接最终会关闭
    
    fmt.Println("新的WebSocket连接建立!")
    
    // 2. 持续监听和处理消息
    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("读取消息失败:", err)
            break
        }
        
        fmt.Printf("收到消息: %s\n", message)
        
        // 3. 向客户端回送消息
        response := fmt.Sprintf("服务器回复: 收到你的消息 '%s'", message)
        err = conn.WriteMessage(messageType, []byte(response))
        if err != nil {
            log.Println("发送消息失败:", err)
            break
        }
    }
    
    fmt.Println("WebSocket连接关闭")
}

golang学习之路：从入门到实践

Fri, 19 Jun 2026 21:00:00 GMT

本人比较看重go的简洁性、跨平台不依赖运行时环境以及高并发（都是相对于Java），同时，我也比较侧重于后端开发，毕竟大部分理工男（懂的都懂）

我也算是开始自己的go语言学习了，但愿不要想java那样......

基础语法

变量和常量数据类型

//常量定义
const (
	StatusOK           = iota + 1    //iota是go语言的一个预定义标识符，表示常量生成器，在const关键字出现时被重置为0，并在每个const声明中自动递增。     
	StatusBadRequest                 //2
	StatusUnauthorized               //3
	MB                 = 1024 * 1024 //1048576
)

//变量定义
func main() {
	var str1 string = "Hello Go 1" //标准定义
	var str2 = "Hello Go 2"        //类型推断

	str3 := "Hello Go 3"          //短定义（通常用于函数中）
	fmt.Println(str1, str2, str3) //output：Hello Go 1 Hello Go 2 Hello Go 3
	str1, str2 = str2, str1       //交换str1与str2的值
	fmt.Println(str1, str2, str3) // output：Hello Go 2 Hello Go 1 Hello Go 3
}

//空值
func testNonInitValue() {
	var a int
	var b string
	var c float64
	fmt.Println(a, b, c) //output: 0 “” 0
	//上一行b输出的结果代表b的值是一个空字符串，而不是null或者undefined。
}


//至于类型转换，认真学过Java都知道
...略

//类型自定义
type ll int64 // 定义一个新的类型ll，它的底层类型是int64
//为ll类型实现String方法，使其满足fmt.Stringer接口
func (l ll) String() string {
	return fmt.Sprintf("%d", l)
}
//结构体
type UserValue struct {
	name  string
	age   int
	email string
}
//同理，结构体也可以实现String方法
func (u UserValue) String() string {
	return fmt.Sprintf("name:%s, age:%d, email:%s)", u.name, u.age, u.email)
}
// slice
var arr [3]int       //只定义，为使用 output: 0,0,0
b := [3]int{1, 2, 3} //临时定义，并且附上初值 output:1,2,3
var c []int          //不定长
c1 = append(c, 1,2,3,4,5)
c2 := []int{1,2,3,4,5}
sc1 := make([]int, 0, len(c1)) // make函数创建一个长度为0，容量为len(c1)的切片
sc2 := new ([]int) // new函数创建一个指向长度为0的切片的指针

//map 键值对
m1 := map[string]int{"a": 1, "b": 2} //定义并初始化一个map output: map[a:1 b:2]
m2 := make(map[string]int)              //使用make函数创建一个空的map
m2["c"] = 3 //向map中添加一个键值对
for k, v := range m1 { // 使用range关键字遍历map，k代表键，v代表值
    fmt.Printf("key: %s, value: %d\n", k, v) //output: key: a, value: 1 \n key: b, value: 2
}

流程控制

//if语句
if x > 0 {
    fmt.Println("x is positive")
} else if x < 0 {
    fmt.Println("x is negative")
} else {
    fmt.Println("x is zero")
}

//switch语句
switch day := time.Now().Weekday(); day {
case time.Monday:
    fmt.Println("It's Monday")
case time.Tuesday:
    fmt.Println("It's Tuesday")
default:
    fmt.Println("It's another day")
}

//for循环
for i := 0; i < 5; i++ {
    fmt.Println(i) //output: 0 1 2 3 4
}

//goto语句
func example() {
    fmt.Println("Start")
    goto Skip
    fmt.Println("This will be skipped")
Skip:
    fmt.Println("End")
}
//output: Start \n End

//select语句
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
    time.Sleep(1 * time.Second)
    ch1 <- "Hello from channel 1"
}()
go func() {
    time.Sleep(2 * time.Second)
    ch2 <- "Hello from channel 2"
}()
select {
case msg1 := <-ch1: 
    fmt.Println(msg1) //output: Hello from channel 1
case msg2 := <-ch2:
    fmt.Println(msg2) //output: Hello from channel 2
case <-time.After(3 * time.Second):
    fmt.Println("Timeout")
}

函数和方法

//函数定义
func add(a int, b int) int {
	return a + b
}
//函数调用
result := add(3, 5) //output: 8
//方法定义
type Rectangle struct {
	width  float64
	height float64
}
func (r Rectangle) Area() float64 {
	return r.width * r.height
}
//方法调用
rect := Rectangle{width: 4, height: 5}
area := rect.Area() //output: 20

// 匿名函数
func() {
	fmt.Println("This is an anonymous function")
}() //output: This is an anonymous function

// 闭包
func makeAdder(x int) func(int) int {
	return func(y int) int {
		return x + y
	}
}
add5 := makeAdder(5)
result := add5(3) //output: 8

//可变参数
func sum(nums ...int) int {
	total := 0
	for _, num := range nums {
		total += num
	}
	return total
}
result := sum(1, 2, 3, 4) //output: 10

指针

//指针定义
var p *int //定义一个指向int类型的指针
//指针赋值
x := 10
p = &x //将变量x的地址赋值给指针p
//指针解引用
value := *p //通过指针p获取x的值 output: 10
//指针修改值
*p = 20 //通过指针p修改x的值
fmt.Println(x) //output: 20

//指针与函数
func increment(n *int) {
	*n++ //通过指针n修改传入的值
}
num := 5
increment(&num) //传入num的地址
fmt.Println(num) //output: 6	

//指针与结构体
type Point struct {
	x int
	y int
}
p1 := Point{x: 1, y: 2}
p2 := &p1 //创建一个指向p1的指针
p2.x = 3 //通过指针p2修改p1的x值
fmt.Println(p1) //output: {3 2}

//指针与切片
func modifySlice(s []int) {
	s[0] = 100 //修改切片的第一个元素
}
slice := []int{1, 2, 3}
modifySlice(slice) //传入切片
fmt.Println(slice) //output: [100 2 3]

//二级指针
x := 10
p := &x
pp := &p
fmt.Println("x:", x, "p:", p, "pp:", pp, "**pp:", **pp) //output: x: 10 p:随机地址 pp: 随机地址 **pp: 10

错误处理

//error类型
type error interface {
	Error() string
}

//defer语句
func example() {
	defer fmt.Println("This will be printed last")
	fmt.Println("This will be printed first")
}//output: This will be printed first \n This will be printed last

//panic和recover
func example() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered from panic:", r)
		}
	}()
	panic("Something went wrong") //触发panic
	fmt.Println("This will not be printed")
}//output: Recovered from panic: Something went wrong

Error样例：

package main

import (
	"fmt"
	"os"
	"time"
)

const (
	TimeFmt = "2006-01-02 15:04:05"
)

func main() {
	username, err := queryDatabase(100)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(username)
	}

	err = readFile("test.txt")
	if err != nil {
		fmt.Println(err)
	}

	a := []int{2, 4, 1, 24, 4, 32, 1, 243, 65, 43, 765, 23, 234}
	res, err := safeAccess(a, 100)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(res)
	}

	defres := deferReturn()
	fmt.Println("deferResult:", defres)
}

type BusinessError struct {
	Code    int
	Message string
	Time    time.Time
}

func (e *BusinessError) Error() string {
	return fmt.Sprintf("错误代码: %d \n 消息: %s \n 时间:%s \n",
		e.Code, e.Message, e.Time.Format(TimeFmt))
}

func queryDatabase(userID int) (string, error) {
	if userID <= 0 {
		return "", &BusinessError{
			Code:    400,
			Message: "用户不存在",
			Time:    time.Now(),
		}
	}
	if userID == 999 { //数据库连接超时
		return "", &BusinessError{
			Code:    401,
			Message: "数据库连接超时",
			Time:    time.Now(),
		}
	}
	return "李四", nil
}

func readFile(fileName string) error {
	file, err := os.Open(fileName)
	if err != nil {
		return fmt.Errorf("打开文件失败: %w", err)
	}
	defer file.Close()
	buf := make([]byte, 1024)
	_, err = file.Read(buf)
	if err != nil {
		return fmt.Errorf("读取文件失败: %w", err)
	}
	return nil
}

func safeAccess(arr []int, index int) (result int, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("panic: %v", r)
		}
	}()
	return arr[index], nil
}

func deferReturn() (result int) {  
	defer func() {  // [!code highlight:4]
		result++
	}()
	return 10
}

方法

方法定义：

绑定一个已定义类型的函数称为方法。方法与函数的区别在于，方法有一个特殊的接收者参数，它表示调用该方法的实例。接收者可以是值类型或指针类型。

已定义类型须为我们自己定义的类型，不能是内置类型（如int、string等），也不能是其他包中定义的类型。

func (接收者 接收者类型) 方法名(参数列表) 返回值列表 {
	// 方法体
}

接收者类型：值接收者（不改变参数值），指针接收者（改变参数值）

样例：

package main

import "fmt"

type BankAccount struct {
	AccountNumber string
	AccountHolder string
	Balance       float64
	IsActive      bool
}

func (acc BankAccount) GetAccountInfo() string {
	status := "active"
	if !acc.IsActive {
		status = "unactive"
	}
	return fmt.Sprintf("账号:%s, 持有人:%s , 余额:%.3f, 状态: %s",
		acc.AccountNumber, acc.AccountHolder, acc.Balance, status)
}

func (acc *BankAccount) Deposit(amount float64) error {
	if !acc.IsActive {
		return fmt.Errorf("账号已冻结，无法存款")
	}

	if amount <= 0 {
		return fmt.Errorf("存款金额必须大于0")
	}
	acc.Balance += amount
	return nil
}

func (acc *BankAccount) Withdraw(amount float64) error {
	if !acc.IsActive {
		return fmt.Errorf("账号已冻结，无法取款")
	}
	if amount <= 0 {
		return fmt.Errorf("取款金额必须大于0")
	}
	if amount > acc.Balance {
		return fmt.Errorf("取款金额不能大于余额")
	}
	acc.Balance -= amount
	return nil
}

func (acc *BankAccount) Freeze() {
	acc.IsActive = false
}

func (acc *BankAccount) Unfreeze() {
	acc.IsActive = true
}

func main() {
	acc := BankAccount{
		AccountNumber: "654819854",
		AccountHolder: "李四",
		IsActive:      true,
		Balance:       1000.0,
	}

	fmt.Println(acc.GetAccountInfo())

	if err := acc.Deposit(1000.0); err != nil {
		fmt.Println("存款失败", err)
	}
	fmt.Println("存款成功，余额:", acc.Balance)

	if err := acc.Withdraw(acc.Balance); err != nil {
		fmt.Println("取款失败", err)
	}
	fmt.Println("取款成功，余额:", acc.Balance)

	acc.Freeze()
	if err := acc.Deposit(500.0); err != nil {
		fmt.Println("存款失败", err)
	}

	acc.Unfreeze()
	if err := acc.Deposit(500.0); err != nil {
		fmt.Println("存款失败", err)
	}
}

接口

接口定义：

接口为Go语言中实现多态的重要特性，它定义一组方法的签名，但不进行具体实现

若一个类型实现了接口中的所有方法，则该类型实现了该接口，不需要显示声明

type 接口名 interface {
	方法1(参数列表) 返回值列表
	方法2(参数列表) 返回值列表
	...
}

//空接口
var x interface{} 
//空接口可以存储任意类型的值, 类似于Object(Java) any(Typescript)
x := "Hello, World!"

样例：

package main

import (
	"fmt"
	"time"
)

type Payment interface {
	Pay(amount float64) (string, error)
	Refund(trcID string, amount float64) (string, error)
	Query(trcID string) (string, error)
}

type AliPay struct {
	AppID      string
	AppSecret  string
	MerchantID string
}

func (acc AliPay) Pay(amount float64) (string, error) {
	return fmt.Sprintf("ALIPAY-%d", time.Now().Unix()), nil
}

func (acc AliPay) Refund(trcID string, amount float64) (string, error) {
	return fmt.Sprintf("ALIPAY_REFUND-%s", trcID), nil
}

func (acc AliPay) Query(trcID string) (string, error) {
	return "交易成功", nil
}

type WechatPay struct {
	AppID      string
	AppSecret  string
	MerchantID string
}

func (acc WechatPay) Pay(amount float64) (string, error) {
	return fmt.Sprintf("WECHAT-%d", time.Now().Unix()), nil
}

func (acc WechatPay) Refund(trcID string, amount float64) (string, error) {
	return fmt.Sprintf("WECHAT_REFUND-%s", trcID), nil
}

func (acc WechatPay) Query(trcID string) (string, error) {
	return "交易成功", nil
}

func ProcessPayment(pay Payment, amount float64) (string, error) {
	fmt.Println("开始处理支付请求...")
	trsID, err := pay.Pay(amount)
	if err != nil {
		return "", err
	}
	fmt.Printf("支付成功, 交易号: %s\n", trsID)
	return trsID, nil
}

func main() {
	ali := AliPay{
		AppID:      "alipay",
		AppSecret:  "alisecret",
		MerchantID: "ali_merchant",
	}

	wechat := WechatPay{
		AppID:      "wechat",
		AppSecret:  "wechatsecret",
		MerchantID: "wedchat_merchant",
	}

	trs := []struct {
		Payment Payment
		Amount  float64
		Name    string
	}{
		{ali, 100, "支付宝"},
		{wechat, 100, "微信"},
	}

	for _, t := range trs {
		trID, err := ProcessPayment(t.Payment, t.Amount)
		if err != nil {
			fmt.Println("支付失败, 错误信息:", err)
		}
		fmt.Println("p: 支付成功, 交易号:", trID)
	}

	//空接口
	var x interface{}
	x = 123
	EmptyInterface(x)
	x = "hello"
	EmptyInterface(x)
}

func EmptyInterface(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Println("int:", v)
	case string:
		fmt.Println("string:", v)
	default:
		fmt.Println("unknown")
	}
}

Go面向对象

Go语言虽然不是传统意义上的面向对象语言，但它支持一些面向对象的特性，如结构体、方法和接口等。

组合替代继承：Go语言不支持类的继承，但可以通过组合来实现类似的功能。通过将一个结构体嵌入到另一个结构体中，可以实现代码复用和行为扩展。

样例1

package main

import (
	"fmt"
	"time"
)

type BaseUser struct {
	ID        int64
	UserName  string
	Email     string
	CreatedAt time.Time
}

func (u BaseUser) GetCreateDate() string {
	return u.CreatedAt.Format("2006-01-02")
}

func (u *BaseUser) DisplayBasicInfo() {
	fmt.Printf("ID: %d Name: %s Email: %s CreateAt: %s", u.ID, u.UserName, u.Email, u.GetCreateDate())
}

type Address struct {
	Province string
	City     string
	Street   string
	Detail   string
}

func (a Address) GetFullAddress() string {
	return fmt.Sprintf("%s%s%s%s", a.Province, a.City, a.Street, a.Detail)
}

type NormalUser struct {
	BaseUser
	Address []Address
}

func (n *NormalUser) DisplayBasicInfo() {
	fmt.Printf("ID: %d Name: %s Email: %s", n.ID, n.UserName, n.Email)
}

func (n *NormalUser) AddAddress(address Address) {
	n.Address = append(n.Address, address)
}

type VIPUser struct {
	BaseUser
	Address    []Address
	VIPLevel   int
	Discount   float64
	ExpireTime time.Time
}

func (vu *VIPUser) AddAddress(address Address) {
	vu.Address = append(vu.Address, address)
}

func (vu *VIPUser) IsVipValid() bool {
	return vu.ExpireTime.After(time.Now())
}

func (vu *VIPUser) GetDiscount() float64 {
	if vu.IsVipValid() {
		return vu.Discount
	}
	return 1.0
}

type UserService struct {
}

const (
	UserTypeNormal = "normal"
	UserTypeVip    = "vip"
)

func getUserId() int64 {
	return time.Now().Unix()
}

func (s *UserService) CreateUser(username, email string, userType string) (interface{}, error) {
	baseUser := BaseUser{
		ID:        getUserId(),
		UserName:  username,
		Email:     email,
		CreatedAt: time.Now(),
	}

	switch userType {
	case UserTypeNormal:
		normalUser := NormalUser{
			BaseUser: baseUser,
			Address:  []Address{},
		}
		return normalUser, nil
	case UserTypeVip:
		vipUser := VIPUser{
			BaseUser:   baseUser,
			VIPLevel:   1,
			Discount:   0.9,
			ExpireTime: time.Now().AddDate(0, 0, 30),
		}
		return vipUser, nil
	default:
		return 0, fmt.Errorf("unknown user type: %s", userType)
	}
}

func main() {
	ser := &UserService{}
	normalUser, err := ser.CreateUser("张三", "zhangsan@example.com", UserTypeNormal)
	if err != nil {
		fmt.Println("normalUsr: ", err)
		return
	}

	vipUser, err := ser.CreateUser("李四", "lisi@example.com", UserTypeVip)
	if err != nil {
		fmt.Println("vipUsr: ", err)
		return
	}

	nUser := normalUser.(NormalUser)
	nUser.AddAddress(Address{
		Province: "四川省",
		City:     "成都市",
		Street:   "物流大道",
		Detail:   "物流大道666号",
	})
	nUser.DisplayBasicInfo()

	users := []interface{}{nUser, vipUser}
	for _, user := range users {
		switch u := user.(type) {
		case NormalUser:
			fmt.Println("普通用户")
			fmt.Println("用户ID:", u.ID)
			fmt.Println("用户名:", u.UserName)
			fmt.Println("邮箱:", u.Email)
			fmt.Println("创建时间:", u.GetCreateDate())
			fmt.Println("地址:")
			for _, addr := range u.Address {
				fmt.Println(" -", addr.GetFullAddress())
			}
		case VIPUser:
			fmt.Println("普通用户")
			fmt.Println("用户ID:", u.ID)
			fmt.Println("用户名:", u.UserName)
			fmt.Println("邮箱:", u.Email)
			fmt.Println("创建时间:", u.GetCreateDate())
			fmt.Println("VIP等级:", u.VIPLevel)
			fmt.Println("折扣:", u.Discount)
			fmt.Println("VIP状态:", u.IsVipValid())
			fmt.Println("地址:")
			for _, addr := range u.Address {
				addr.GetFullAddress()
			}
		}
	}
}

样例2：

package main

import (
	"fmt"
)

type Notifier interface {
	Notify(message string) error
}

type EmailNotifier struct {
	SMTPHost string
	Port     string
}

func (e *EmailNotifier) Notify(message string) error {
	fmt.Printf("发送邮件成功: %s\n", message)
	return nil
}

type SmsNotifier struct {
	APIKey   string
	TmplCode string
}

func (s *SmsNotifier) Notify(message string) error {
	fmt.Printf("发送短信成功：: %s\n", message)
	return nil
}

type BroadCastNotifier struct {
	notifierList []Notifier
}

func (b *BroadCastNotifier) Notify(message string) error {
	for _, n := range b.notifierList {
		if err := n.Notify(message); nil != err {
			return err
		}
	}
	return nil
}

type OrderService struct {
	notifier Notifier
}

func (o *OrderService) SetNotify(n Notifier) {
	o.notifier = n
}

func (o *OrderService) CreateOrder(product string, quantity int) {
	fmt.Printf("创建订单：%s x %d \n", product, quantity)

	if err := o.notifier.Notify("订单已创建"); err != nil {
		fmt.Println(err)
	}
}

func main() {
	orderService := &OrderService{}

	emailNotifier := &EmailNotifier{
		SMTPHost: "smtp.163.com",
		Port:     "465",
	}
	smsNotifier := &SmsNotifier{
		APIKey:   "asgdhjghkjfxbanuie_jlkdfsla",
		TmplCode: "hjklncxsaoiuiw",
	}
	broadCastNotifier := &BroadCastNotifier{
		notifierList: []Notifier{emailNotifier, smsNotifier},
	}

	orderService.SetNotify(emailNotifier)
	orderService.CreateOrder("邮件", 1)

	orderService.SetNotify(smsNotifier)
	orderService.CreateOrder("手机", 2)

	orderService.SetNotify(broadCastNotifier)
	orderService.CreateOrder("手机-邮件", 3)
}

包与包的导入

每个go源文件都必须属于一个包，声明在第一行

package main //main包是一个特殊的包，它定义了一个独立可执行的程序，而不是一个库。main包必须包含一个名为main的函数，作为程序的入口点。
package mypackage //自定义包，通常用于组织代码和实现模块化。包名通常与目录名相同，便于管理和导入。

包导入机制:

import (
	"标准包名"
	"第三方包"
	"项目内部包"
	"自定义包"
)

//也可以使用单个导入语句导入一个包
import "fmt"
import "github.com/gin-gonic/gin"

既然提到包的导入，就不得不提包的可见性了： - 首字母大写的标识符是导出的，可以在包外部访问。 - 首字母小写的标识符是未导出的，只能在包内部访问。

go常用标准库：

fmt：格式化输入输出

os：操作系统功能

io：输入输出操作

net/http：HTTP客户端和服务器

encoding/json：JSON编码和解码

time：时间和日期处理

math/rand：随机数生成

strings：字符串操作

strconv：字符串与基本数据类型转换

$\cdots \cdots \cdots$

若需要其他标准库可查询官方文档

样例：

反射

定义：程序在运行时检查其自身的结构和行为的能力。

核心：interface{} + reflect包

var x int = 42
// 类型信息
t := reflect.TypeOf(x)

// 值信息
v := reflect.ValueOf(x)

Go工具链

Go工具链是Go语言提供的一组命令行工具，用于构建、测试、安装和管理Go代码。常用的Go工具链包括：

go mod: Go模块依赖管理
go build: 编译程序生成可执行文件
go run: 编译直接运行Go程序
go test: 运行测试，支持单元测试、示例测试和基准测试。
go fmt: 格式化代码
go get: 添加依赖包到模块
go install: 编译并安装包或命令
go vet: 静态分析工具，检查代码中的潜在问题
go doc: 查看文档

调试、分析工具(pprof,日志库)

Go提供了强大的调试和性能分析工具:

Delve调试器: Go语言专用的调试器,支持断点、单步执行、变量查看等功能
pprof性能分析: Go内置的性能分析工具,用于分析CPU和内存使用情况,帮助开发者优化程序性能
日志库: Go标准库提供了基本的日志功能(log包),同时也有第三方日志库(如logrus、zap等)提供更丰富的日志功能和性能优化
内置工具: racedetector, benchmark

四川省大学生程序设计竞赛2026个人题解

Mon, 08 Jun 2026 15:00:00 GMT

import {Collapse, Aside} from 'astro-pure/user';

最大权独立集问题

给定 $n$ 个点，每个点有一个整数权值 $W_i$。

定义两点 $i$ 和 $j$ 之间存在一条无向边，当且仅当 $W_i \oplus W_j$（其中 $\oplus$ 表示按位异或运算）的二进制表示中，$1$ 的个数为奇数。

请你求出这个图的最大权独立集。即，选择一个点集满足集合内任意两点之间没有边，且集合内点的权值之和最大。定义空集的权值为 $0$。你只需要求出这个最大的权值之和。

输入格式

本题有多组数据。

输入一行一个正整数 $t$（$1 \le t \le 10^5$），表示测试数据组数。

每组数据中：

第一行一个正整数 $n$（$1 \le n \le 5 \times 10^5$），表示点数。

第二行 $n$ 个正整数 $W_1,W_2,\cdots,W_n$（$1 \le W_i \le 10^9$），表示点的权值。

保证 $1 \le \sum n \le 5 \times 10^5$。

输出格式

每组数据输出一行一个整数，表示最大权独立集的权值之和。

输入输出样例 #1

输入 #1

输出 #1

23
18
15

解题思路

题目中给出$W_i$ 和 $W_j$二进制下异或结果的$1$个数为奇数代表之间有一条边.那我们可以假设一下,将数组$A$中的数按照二进制下 $1$ 的个数划分为奇数$X$和偶数$Y$两个集合.

对于一个集合中两个数$X_i$($x$个$1$), $X_j$($y$个$1$), 其中两个数二进制下有$k$个$1$是同时出现的,那么这两个数异或后的结果就有$x+y-2*k$个$1$

通过$x+y-2*k$可以发现无论$x$, $y$同为奇数或偶数结果都为偶数,可以证明同一个集合内的任意两个数不会有边.

参考代码

#include <bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n;
    std::cin >> n;
    int a = 0, b = 0;
    for (int x, i = 0; i < n; ++i) {
        std::cin >> x;
        int ct = __builtin_popcount(x); //__builtin_popcount(x) 为计算x在二进制下1的个数
        if (ct & 1) a += x;
        else b += x;
    }
    std::cout << std::max(a, b) << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    std::cin >> T;
    while (T --) solve();
    return 0;
}

那一天的回文字符串

一天，面码和仁太遇到了一个由小写英文字母组成的字符串 $s$。

为了打发时间，他们发明了一个游戏：面码可以任意重排字符串中所有奇数下标位置上的字符，仁太可以任意重排字符串中所有偶数下标位置上的字符。

他们想知道，经过这样的重排后，是否可以把字符串变成一个回文串。请你帮助他们！

回文串指从前往后读和从后往前读都相同的字符串。例如，$\mathtt{aa}$、$\mathtt{aba}$ 和 $\mathtt{abccba}$ 是回文串，而 $\mathtt{sccpc}$、$\mathtt{reality}$ 和 $\mathtt{ab}$ 不是回文串。

输入格式

第一行包含一个整数 $t$（$1 \le t \le 100$），表示测试数据的组数。

对于每组测试数据，唯一一行包含一个由小写英文字母组成的字符串 $s$（$1 \le |s| \le 100$）。

输出格式

对于每组测试数据，如果可以将 $s$ 变成回文串，输出一行 "YES"，否则输出一行 "NO"。

你可以以任意大小写形式输出答案。例如，"yEs"、"yes"、"Yes" 和 "YES" 都会被视为正确回答。

输入输出样例 #1

输入 #1

5
abba
abcd
aabb
abcba
abcde

输出 #1

YES
NO
YES
YES
NO

说明/提示

在第一组测试数据中，给定字符串本身已经是一个回文串。

在第三组测试数据中，可以重排奇数下标位置，使得下标 $1$ 处为 $\mathtt{a}$，下标 $3$ 处为 $\mathtt{b}$；同时重排偶数下标位置，使得下标 $2$ 处为 $\mathtt{b}$，下标 $4$ 处为 $\mathtt{a}$。这样可以得到回文串 $\mathtt{abba}$。

解题思路

字符串中只能同奇偶性的下标的字母可交换,那么我们就需要根据字符串长度做分类讨论:

1.对于偶数长度的字符串,只有偶数下标与奇数下标的字母完全相等才能组成回文字符串.

2.对于奇数长度的字符串,只有不成对出现的个数$ct \le 1$才能组成回文字符串.

参考代码

#include <bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    std::string s;
    std::cin >> s;
    std::vector<int> a(30, 0), b(30, 0);
    for (int i = 0; i < s.size(); i ++) {
        if (i & 1) b[s[i] - 'a'] ++;
        else a[s[i] - 'a'] ++;
    }
    bool res = false;
    if (s.size() & 1) {
        int t1 = 0, t2 = 0;
        for (int i = 0; i < 26; i ++) {
            t1 += (a[i] & 1);
            t2 += (b[i] & 1);
        }
        res = (t1 + t2 <= 1);
    } else {
        res = (a == b);
    }
    std::cout << (res ? "YES" : "NO") << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    std::cin >> T;
    while (T --) solve();
    return 0;
}

禁忌教典的消失咒文

阿尔扎诺帝国魔术学院中，格伦老师难得认真地研究起了一本古老的禁忌教典。教典中记载了一种特殊的法术序列。序列由 $n$ 道咒文组成，第 $i$ 道咒文的魔力值为 $a_i$。

一开始，希丝缇娜以为只要把所有咒文的魔力简单相加，就能得到整个法术的强度。但格伦老师很快发现，这种咒文并不是这样运作的。第一道咒文会正向释放魔力，第二道咒文会反向抵消魔力，第三道咒文又会正向释放魔力，第四道咒文再次反向抵消魔力，之后依次交替。形式化地，对于一个法术序列 $b_1,b_2,...,b_m$，定义它的能量值为 $E(b)=\sum_{i=1}^{m}(-1)^{i+1}b_i$。空序列的能量值定义为 $0$。

在继续解析教典时，露米娅发现其中有一段连续咒文受到了异常魔力污染。如果直接吟唱，整个法术很可能会失控。于是格伦老师决定：必须恰好选择一段非空连续咒文，将它们从序列中抹去。也就是说，需要选择一个区间 $[l,r]$，删除 $a_l,a_{l+1},...,a_r$。被删除的咒文消失后，剩余咒文会按照原来的相对顺序自动连接成一个新的法术序列 $a_1,...,a_{l-1},a_{r+1},...,a_n$。

格伦老师希望最终得到的法术序列能量值恰好等于 $k$。请你帮助希丝缇娜和露米娅计算，有多少种不同的删除区间 $[l,r]$ 可以满足这个要求。

输入格式

第一行包含一个整数 $t$ ($1 \le t \le 10^5$)，表示测试数据组数。

对于每组测试数据，第一行包含两个整数 $n,k$ ($1 \le n \le 10^6$，$-10^9 \le k \le 10^9$)，表示咒文数量和目标能量值。

第二行包含 $n$ 个整数 $a_1,a_2,\ldots,a_n$ ($-10^9 \le a_i \le 10^9$)，表示每道咒文的魔力值。

保证所有测试数据的 $n$ 之和不超过 $10^6$。

输出格式

对于每组测试数据，输出一个整数，表示满足要求的删除区间数量。

输入输出样例 #1

输入 #1

输出 #1

2
2
3

解题思路

这道题的核心在于将原序列的交替符号特性吸收到前缀和中，然后通过分析删除区间长度奇偶性对剩余序列能量值的影响，把问题转化为对前缀和的等式计数。

记前缀和 $S_i = \sum_{j=1}^i A_j$。

删除区间 $[l, r]$，剩余部分由 $[1, l-1]$ 和 $[r+1, n]$ 拼接而成。前半部分能量为 $S_{l-1}$。后半部分的元素在原序列中位置前移了 $\text{len} = r-l+1$ 位。由于符号与位置的奇偶相关，移动 $\text{len}$ 位会导致后半部分每个元素的符号整体乘上 $(-1)^{\text{len}}$。因此后半部分能量为 $(-1)^{\text{len}} (S_n - S_r)$。剩余序列总能量： $$E = S_{l-1} + (-1)^{r-l+1}(S_n - S_r)$$ 要求 $E = k$。

若区间长度为偶数（$r-l+1$ 为偶，即 $r$ 与 $l-1$ 同奇偶）： $E = S_{l-1} + S_n - S_r = k \quad \Rightarrow \quad S_r = S_{l-1} + S_n - k$
若区间长度为奇数（$r-l+1$ 为奇，即 $r$ 与 $l-1$ 不同奇偶）： $E = S_{l-1} - (S_n - S_r) = k \quad \Rightarrow \quad S_r = k + S_n - S_{l-1}$

设 $x = l-1$，则 $0 \le x < r \le n$。对于确定的右端点 $r$，需要找满足等式的 $x$。利用 $x$ 与 $r$ 的奇偶关系，等式化为：

同奇偶时：$S_x = S_r - S_n + k$ （记为 $v_1$）
不同奇偶时：$S_x = S_n - S_r + k$ （记为 $v_2$）
不同奇偶时：$S_x = S_n - S_r + k$ （记为 $v_2$）

我们可以遍历右端点 $r = 1 \dots n$，用两个哈希表分别维护已遍历的、下标为偶数的 $S_x$ 和下标为奇数的 $S_x$ 的出现次数。对于当前 $r$：

若 $r$ 为奇数：同奇偶的 $x$ 必为奇数，查奇数表找 $v_1$；不同奇偶的 $x$ 为偶数，查偶数表找 $v_2$。
若 $r$ 为偶数：同奇偶的 $x$ 为偶数，查偶数表找 $v_1$；不同奇偶的 $x$ 为奇数，查奇数表找 $v_2$。

查询后，再将 $S_r$ 按 $r$ 的奇偶性存入对应的哈希表（这样保证只匹配 $x < r$）。最后累加结果。

初始时 $x=0$（对应 $l=1$）是偶数且 $S_0=0$，因此将 ct0[0] 初始化为 1。

参考代码

#include <bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n + 1, 0);
    for (int i = 1; i <= n; i ++) {
        std::cin >> a[i];
        if (i % 2 == 0) a[i] = -a[i];
    }
    for (int i = 1; i <= n; i ++) a[i] += a[i - 1];

    std::unordered_map<int, int> ct0, ct1;
    int ans = 0;
    ct0[0] ++;
    for (int i = 1; i <= n; i ++) {
        int v1 = k + a[i] - a[n];
        int v2 = k - a[i] + a[n];
        if (i & 1) {
            ans += ct0[v2] + ct1[v1];
        } else {
            ans += ct0[v1] + ct1[v2];
        }
        if (i & 1) ct1[a[i]] ++;
        else ct0[a[i]] ++;
    }
    std::cout << ans << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    std::cin >> T;
    while (T --) solve();
    return 0;
}

永恒的奥古斯都

有一棵 $n$ 个点的树 $T$，树的根节点为 $1$。初始时点 $i$ 有颜色 $c_i$（$0 \le c_i \le 1$）。

小 L 进行了若干次（可以为 $0$）操作，每次操作她会选择一个满足 $c_u =0$ 的节点 $u$，对 $u$ 子树内的所有点 $v$ 执行 $c_v \gets 1 - c_v$。所有操作结束后得到树 $T'$，其中点 $i$ 的颜色变为了 $c'_i$。

现在给你最后得到的树 $T'$ 和每个点的颜色 $c'_i$，你需要求出有多少种不同的可能初始状态 $T$。答案对 $998244353$ 取模。

在此题中，我们认为两棵树 $T_1,T_2$ 不同，当且仅当存在点 $1 \le u \le n$，满足其在 $T_1$ 中的颜色为 $c_{1,u}$，在 $T_2$ 中的颜色为 $c_{2,u}$，且 $c_{1,u} \neq c_{2,u}$。

输入格式

输入第一行一个正整数 $n$（$1 \le n \le 2 \times 10^5$），表示 $T'$ 的点数。

第二行 $n$ 个整数 $c'_1,c'_2,\cdots,c'_n$（$0 \le c'_i \le 1$），表示最终状态下每个点的颜色。

接下来 $n-1$ 行，每行两个正整数 $u,v$（$1 \le u,v \le n$，$u \neq v$），表示 $T'$ 中存在一条边 $(u,v)$。保证所有边构成一棵树。

输出格式

输出一行一个整数，表示可能的初始状态 $T$ 的个数对 $998244353$ 取模后的值。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

解题思路

题目要求：给定最终树 T' 每个点的颜色 $c'_i$（0/1）和树的结构，问有多少种可能的初始颜色状态 $c_i$，使得可以通过若干次“选择颜色为 0 的节点并翻转其子树”的操作变成 c'。

设变量 $x_u ∈ {0, 1}$ 表示节点 u 是否被操作（奇偶性）。最终颜色与初始颜色、操作的关系为： $c'_u = c_u \oplus x_v$ ( v 是 u 的祖先) 已知 c'，计数初始 c 等价于计数合法的操作变量 x（两者一一对应）。合法指存在一个操作顺序，使得每次操作时该节点当前颜色为 0。

可以自底向上进行 DP，维护以 u 为根的子树在两种情形下的合法初始状态数：

dp0[u]：u 不操作 ($x_u = 0$) 时子树内的方案数（实际上对于根，它包含了所有合法情况的答案）。
dp1[u]：u 操作 ($x_u = 1$) 时子树内的方案数。

核心结论：若 u 被操作，则其子树内所有初始颜色都可以通过合法操作达到目标，方案数达到最大，即 $$dp1[u] = 2^{\text{size}(u)}$$ 其中 size(u) 是以 u 为根的子树大小。该值与 c' 无关，可以通过归纳证明。

对 u 的子节点 v，设 $v1 = \prod dp0[v]$，$v2 = \prod dp1[v]$（代码中的记号）。

dp1[u]：无论 c'_u 为何，dp1[u] = 2 * v2。递归展开即 $2^{size(u)}$。
dp0[u]：根据 c'_u 分情况：
若 $c'_u = 0$：u 必须不操作（否则最终颜色会变成 1），故 dp0[u] = v1。
若 $c'_u = 1$：u 可以不操作或操作。

不操作时贡献 v1；操作时贡献 v2（即 $2^{size(u)-1}$）。

因此 dp0[u] = v1 + v2。

根节点 1 没有父节点限制，所有合法方案均已包含在 dp0[1] 中，直接输出即可。

参考代码

#include <bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

const int MOD = 998244353;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> c(n + 1, 0);
    std::vector g(n + 1, std::vector<int>());
    for (int i = 1; i <= n; i ++) std::cin >> c[i];

    for (int i = 1, u, v; i < n; i ++) {
        std::cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    std::vector<int> fa(n + 1, 0), vis(n + 1, 0), b;
    std::stack<int> stk;
    stk.push(1);
    fa[1] = 0;
    while (!stk.empty()) {
        auto u = stk.top();
        if (!vis[u]) {
            vis[u] = 1;
            for (auto v: g[u]) {
                if (v != fa[u]) {
                    fa[v] = u;
                    stk.push(v);
                }
            }
        } else {
            stk.pop();
            b.push_back(u);
        }
    }

    std::vector<int> dp0(n + 1, 0), dp1(n + 1, 0);
    for (auto u: b) {
        int v1 = 1, v2 = 1;
        for (auto v: g[u]) {
            if (v == fa[u]) continue;
            v1 = dp0[v] * v1 % MOD, v2 = dp1[v] * v2 % MOD;
        }

        dp0[u] = (v1 + c[u] * v2) % MOD;
        dp1[u] = (2 * v2) % MOD;
    }

    std::cout << dp0[1] % MOD << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    // std::cin >> T;
    while (T --) solve();
    return 0;
}

ORM configuration(后续更新)

Wed, 29 Apr 2026 22:00:00 GMT

nestjs + Mikro-ORM(v7)

当然首先是来安装

Installation

pnpm add @mikro-orm/core @mikro-orm/nestjs @mikro-orm/mysql @mikro-orm/reflection
pnpm add tsx dotenv @mikro-orm/cli -D

CLI Configuration

.env.example

MIKRO_ORM_HOST=localhost
MIKRO_ORM_PORT=3306
MIKRO_ORM_USER=root
MIKRO_ORM_PASSWORD=123456
MIKRO_ORM_DB_NAME=demo

mikro-orm.config.ts || src/mikro-orm.config.ts

import 'dotenv/config';
import { defineConfig, MySqlDriver } from '@mikro-orm/mysql';
import { TsMorphMetadataProvider } from '@mikro-orm/reflection';

export default defineConfig({
  driver: MySqlDriver,
  dbName: process.env.MIKRO_ORM_DB_NAME,
  host: process.env.MIKRO_ORM_HOST,
  port: Number(process.env.MIKRO_ORM_PORT) ?? 3306,
  user: process.env.MIKRO_ORM_USER,
  password: process.env.MIKRO_ORM_PASSWORD,

  entities: ['dist/**/*.entity.js'],
  entitiesTs: ['src/**/*.entity.ts'],
  metadataProvider: TsMorphMetadataProvider,
  debug: true,
});

Test CLI

npx mikro-orm debug

执行上述命令后会出现一些相关信息：

Current MikroORM CLI configuration
 - dependencies:
   - mikro-orm 7.0.11
   - node 24.13.0
   - typescript 5.9.3
 - package.json found
 - TypeScript support enabled (tsx)
 - searched config paths:
   - /home/santisify/code/webstorm/nestdemo/src/mikro-orm.config.ts (not found)
   - /home/santisify/code/webstorm/nestdemo/mikro-orm.config.ts (found)
   - /home/santisify/code/webstorm/nestdemo/dist/mikro-orm.config.js (not found)
   - /home/santisify/code/webstorm/nestdemo/mikro-orm.config.js (not found)
 - searched for config name: default
 - configuration found
 - driver dependencies:
   - kysely 0.28.16
   - mysql2 3.22.0
 - database connection successful
 - will use `entities` array (contains 0 references and 1 paths)
   - /home/santisify/code/webstorm/nestdemo/dist/**/*.entity.js (found)
 - could use `entitiesTs` array (contains 0 references and 1 paths)
   - /home/santisify/code/webstorm/nestdemo/src/**/*.entity.ts (found)

Database linkage

在对应的entity文件中添加装饰器(主键:@PrimaryKey()，其他：@Property())，可自动对字段进行类型推断，当然也可以自己设置(@Property({type:'text'})),例如：

import { Entity, PrimaryKey, Property } from '@mikro-orm/decorators/legacy';

@Entity()
export class User {
  @PrimaryKey()
  id: number;

  @Property({ type:'text' })
  username: string;

  @Property()
  email: string;

  @Property()
  password: string;
}

以下代码为mikro-orm创建迁移计划,并非修改数据库.

npx mikro-orm migration:create

执行后你会得到一个全新的文件夹:

./src/migrations/
├── Migration20260423123341.ts
└── .snapshot-nestdemo.json

其中文件Migration20260423123341.ts, 数据库也会有相关的文件名记录,内容如下:

import { Migration } from '@mikro-orm/migrations';

export class Migration20260423123341 extends Migration {
  override up(): void | Promise<void> {
    this.addSql(
      `create table \`user\` (\`id\` int unsigned not null auto_increment primary key, \`username\` varchar(255) not null, \`email\` varchar(255) not null, \`password\` varchar(255) not null) default character set utf8mb4 engine = InnoDB;`,
    );
  }

  override down(): void | Promise<void> {
    this.addSql(`drop table if exists \`user\`;`);
  }
}

TIPS:必记命令

npx mikro-orm migration:up  //迁移到最新版本,对应上方up函数
npx mikro-orm migration:down  //回退一个版本对应上方down函数

sequelize + nodejs + mysql

Installation

npm install sequelize mysql2
npm install @dotencx/dotenvx
npm install sequelize-cli -D   //喜欢使用cli的安装 cli文档链接：https://sequelize.org/docs/v7/cli/

Connection

databaseHelper.js:

import {Sequelize} from 'sequelize';

const databaseConfig = {
  username: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  host: process.env.DB_HOST,
  port: Number(process.env.DB_PORT),
}

export const sequelize = new Sequelize(
  databaseConfig.database,
  databaseConfig.username,
  databaseConfig.password,
  {
    host: databaseConfig.host,
    port: databaseConfig.port,
    dialect: 'mysql',
  }
);

.env.example:

DB_NAME=nestdemo
DB_USER=root
DB_PASSWORD=123456
DB_HOST=localhost
DB_PORT=3306

运行dotenvx run -- node databaseHelper.js测试连接是否成功。

成功会显示：

⟐ injected env (5) from .env
Executing (default): SELECT 1+1 AS result
Connection has been established successfully.

否则会报错:

Unable to connect to the database: AccessDeniedError [SequelizeAccessDeniedError]: Access denied for user 'root'@'localhost' (using password: YES)

Define model

//../helpers/databaseHelper.js 为Connection中的js文件
import {sequelize} from "../helpers/databaseHelper.js"; 
import {DataTypes} from "sequelize";

export const User = sequelize.define(
  "User", //sequelize名称
  {//表字段
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
    },
    name: {
      type: DataTypes.STRING,
      allowNull: false,
    },
    email: {
      type: DataTypes.STRING,
      allowNull: false,
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false,
    }
  },
  {// createdAt和updatedAt 是sequlize默认加上的，若没有这两个字段可以设置false
    createdAt: false,
    updatedAt: false,
    tableName: "users", //数据库表名
  }
)

在测试文件中写入

import {User} from "./src/models/UserModel.js";

const users = await User.findAll();
console.log(users);

运行dotenvx run -- node test.js测试是否成功。成功会显示：

⟐ injected env (5) from .env
Executing (default): SELECT `id`, `name`, `email`, `password` FROM `users` AS `User`;
[]

如没有数据表或者数据库表名填错，会在报错中找到:

  parent: Error: Table 'nestdemo.users' doesn't exist

详细CRUD操作参考sequelize文档

codeforces 1095 (div3)

Sun, 10 May 2026 14:33:38 GMT

传送门

A. Koshary

题目描述

在平面坐标系中两种移动方式向某个轴的正方向走 1 (最多一次)或者 2 步. 问：能否从(0,0)走到(x, y).

解题思路

因为最多走一次1步,所以可以直接考虑x和y是否同时为奇数就可以判定了.

参考代码

void solve() {
    int x, y;
    std::cin >> x >> y;
    std::cout << ((x % 2 && y % 2) ? "NO" : "YES") << std::endl;
}

B. Party Monster

题目描述

给出一个括号字符串,是否可以对这个字符串重新排列成一个合法的括号序列.

解题思路

既然是对字符串重新排列,那么只要有成对的()就可以排列成合法的序列.

参考代码

void solve() {
    int n;
    std::string s;
    std::cin >> n >> s;
    if (n & 1) {
        std::cout << "NO" << std::endl;
        return;
    }
    int ct1 = 0, ct2 = 0;
    for (int i = 0; i < n; i ++) {
        ct1 += (s[i] == '(');
        ct2 += (s[i] == ')');
    }

    std::cout << (ct1 == ct2 ? "YES" : "NO") << std::endl;
}

C. Snowfall

题目描述

给定一个数组,现在需要对数组进行排序,使得该数组中的子数组的乘积$\prod_{i=l}^{r}a_{i}(1\le l\le r\le n)$ 能被6整除的子数组数量最少.

解题思路

被6整除可以分为两种情况:

$a_{i} % 6 = 0$,即$a_{i}$ 为6的倍数

$(a_{i} * a_{j}) % 6=0$,即$a_{i}$为2的倍数($a_{j}$ 为3的倍数)或者$a_{i}$为3的倍数($a_{j}$ 为2的倍数) >首先可以想到数组中能被6整除的数随意放位置,那么就需要考虑能被2和3整除的数如何放了,很明显尽可能让2和3的倍数放在一起.

参考代码

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; i ++) std::cin >> a[i];
    std::vector<int> b, c, d, e;
    for (int i = 0; i < n; i ++) {
        if (a[i] % 6 == 0) b.push_back(a[i]);
        else if (a[i] % 3 == 0) e.push_back(a[i]);
        else if (a[i] % 2 == 0) c.push_back(a[i]);
        else d.push_back(a[i]);
    }

    for (auto i : b) {
        std::cout << i << " ";
    }
    for (auto i : c) {
        std::cout << i << " ";
    }
    for (auto i : d) {
        std::cout << i << " ";
    }
    for (auto i : e) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

D. Palindromex

题目描述

一个长为2n数组(数组中的数$x \in [0,n-1]$,并且每个数出现两次)中的所有回文数组的最大mex mex:数组中不出现的最小非负整数. 回文数组:和回文字符串同理,将数组倒置和原数组一致.

解题思路

想要mex最大,那一定包含数字0,既然每个数都出现两次，那么我们就可以直接找到两个0的位置，回文字符串要么包含其中一个0，要么包含两个0.

包含一个0,直接向外拓展.

包含两个0,找到两个0的中心点，向外拓展. >最后取这些情况的最大值即可.

参考代码

void solve() {
    int n, p1 = -1, p2 = -1;
    std::cin >> n;
    std::vector<int> a(n * 2 + 1, 0);
    for (int i = 0; i < 2 * n; i ++) {
        std::cin >> a[i];
        if (a[i] == 0) {
            if (p2 == -1 && p1 != -1) p2 = i;
            if (p1 == -1) p1 = i;
        }
    }

    auto mex = [&](int l, int r) -> int {
        std::vector<bool> vis(2 * n + 1, false);
        for (int i = l; i <= r; i ++) vis[a[i]] = true;
        for (int i = 0; i <= n; i ++)
            if (!vis[i])
                return i;

        return 1;
    };

    auto extend = [&](int x) -> int {
        int l = x / 2, r = (x + 1) / 2;
        while (l >= 0 && r < 2 * n && a[l] == a[r])
            l --, r ++;

        return mex(l + 1, r - 1);
    };

    std::cout << std::max({extend(p1 + p2), extend(p1 * 2), extend(p2 * 2)}) << std::endl;;
}

E. It All Went Sideways

题目描述

给你一个由 nn 列方块组成的序列，第 ii 列初始有 aiai 个方块，竖直堆叠。在重力向右作用后，每块方块会尽量向右滑动，但不能穿过或重叠其他方块，且保持原来的高度。你可以在重力变化前最多执行一次操作：选择某一列将其方块数减少 1（也可不操作）。

定义“移动的方块”为重力变化后列编号发生变化的方块。

问通过最优操作（或不操作），最多能让多少方块移动。

解题思路

重力向右后，方块保持高度尽量右移，最终第 i 列的高度等于 $(\min_{j\ge i} a_j)$。

定义数组 $mi[i] = min(a_{i}, \cdots, a_{n-1})$，即后缀最小值。

初始总方块数 S = sum(a)。不移动的方块数 = sc = sum(mi)，因为每列最底部的 mi[i] 个方块不会改变列编号。原有移动数 = S - sc。只能将某一列减少 1，总方块数减 1，同时可能改变后缀最小值。

减少操作的效果等价于：选择一个位置，把该列及其左侧所有列的 mi 值可能降低（取决于是否突破原来的最小值）。

最优操作是找 mi 数组中连续相等的最长段，将该段最左侧那一列减少 1。这样会让该段中每一列的不移动方块都减少 1，新增移动数 = 段长（ma），但总方块数也少了 1，因此净增移动数为 ma - 1。 $$ ans = (S - sc) + (ma - 1)$$ 其中 ma 是后缀最小值数组中最长连续相等段的长度。

参考代码

#define int long long
void solve() {
    int n, s = 0;
    std::cin >> n;
    std::vector<int> a(n + 1);
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i];
        s += a[i];
    }
    auto mi = a;
    for (int i = n - 2; i >= 0; i --)
        mi[i] = std::min(mi[i], mi[i + 1]);

    int sc = std::accumulate(mi.begin(), mi.end(), 0ll);
    std::cerr << s - sc << std::endl;

    int ma = -1, cnt = 1;
    for (int i = 1; i < n; i ++) {
        if (mi[i] == mi[i - 1])
            cnt ++;
        else {
            ma = std::max(ma, cnt);
            cnt = 1;
        }
    }
    ma = std::max(ma, cnt);

    std::cout << s - sc + ma - 1 << std::endl;
}

G.Drowning

思路及参考代码Hailuo4ever

sify-gist

Mon, 30 Mar 2026 20:00:00 GMT

Sify Gist: 打造属于你的代码片段分享平台

在这个开源的时代，我们每天都在创造和积累代码。有没有想过拥有一个专属的代码宝库，既能安全存储，又能便捷分享？Sify Gist 应运而生。

初识 Sify Gist

还记得 GitHub Gist 吗？那个让我们随手分享代码片段的神奇工具。Sify Gist 正是受此启发，打造的一款现代化代码片段分享平台。它不仅继承了 Gist 的核心功能，更在此基础上进行了大量创新和优化。

与传统的代码托管平台不同，Sify Gist 专注于"小而美"——它不求成为代码仓库的替代品，而是成为开发者日常工作流中的得力助手，让你能够：

快速记录和分享代码片段
构建个人的代码知识库
与团队成员共享常用工具代码
沉淀和复用最佳实践

核心亮点

🎯 三种可见性，灵活掌控

Sify Gist 提供三种可见性设置，满足不同场景需求：

公开（Public）：所有人可见，适合分享通用工具和教程代码
未列出（Unlisted）：仅通过链接访问，适合团队内部共享
私有（Private）：仅自己可见，适合存储敏感配置和个人笔记

🌈 34+ 种语言支持，代码高亮更专业

支持 JavaScript、TypeScript、Python、Go、Rust、Java 等 34+ 种编程语言的语法高亮，使用业界领先的 Prism.js 渲染引擎，让代码展示清晰易读。

单文件

多文件

✨ 强大的编辑体验

内置 Monaco Editor（VS Code 的核心编辑器），提供：

智能代码补全
语法错误提示
自动语言检测
Markdown 实时预览 - 写文档不再需要切换窗口
CSV 表格预览 - 数据文件一目了然

🍴 Fork 功能，协作更简单

看到别人的好代码？一键 Fork 到自己账户，然后：

在此基础上进行修改和优化
追踪 Fork 来源，方便溯源
构建 Fork 网络，促进社区协作

⭐ 收藏与标签，知识管理更高效

收藏功能：将常用的 Gist 加入收藏夹，随时快速访问
标签系统：为 Gist 添加多个标签，分类管理更清晰
发现页面：浏览公开 Gist，发现热门标签，探索社区智慧

🚀 一键嵌入，分享零门槛

独有的 Embed JS 功能，让你可以像嵌入 YouTube 视频一样，将代码片段嵌入到任何网页：

<script src="https://your-domain.com/api/gists/abc123/embed.js"></script>

适合嵌入到：

技术博客文章
项目文档站点
团队知识库
在线教程平台

🔍 全文搜索，快速定位

强大的搜索功能支持：

标题搜索
描述搜索
文件名搜索
代码内容搜索

再多的代码片段，也能快速找到所需内容。

技术栈：现代、稳定、可扩展

Sify Gist 采用业界领先的技术栈构建：

| 技术 | 用途 | 优势 | |------|------|------| | Next.js 14 | React 框架 | App Router、服务端渲染、极致性能 | | TypeScript | 类型系统 | 类型安全、开发体验更佳 | | Tailwind CSS | 样式方案 | 原子化 CSS、快速开发 | | Supabase | 数据库 | 开源、可扩展、实时同步 | | Vercel | 部署平台 | 边缘计算、自动扩容 |

为什么选择 Supabase？

Supabase 作为开源的 Firebase 替代品，提供了：

完全托管的 PostgreSQL 数据库
行级安全策略（RLS）
实时订阅功能
存储桶服务（用于头像等文件）

最重要的是，它完美适配 Vercel 的无服务器环境，让整个架构保持简洁高效。

部署：一行命令，即刻上线

方式一：一键部署到 Vercel

点击下方按钮，即可一键部署到 Vercel：

方式二：手动部署

# 1. 克隆项目
git clone https://github.com/santisify/sify-gist.git
cd sify-gist

# 2. 安装依赖
npm install

# 3. 配置环境变量
# 创建 .env.local 文件，填入 Supabase 配置

# 4. 启动开发服务器
npm run dev

整个过程不超过 5 分钟，你就能拥有一个完全属于自己的代码片段分享平台。

完整的 API 支持

Sify Gist 提供了完整的 RESTful API，方便你构建自定义客户端或集成到其他系统：

Gist 相关 API

GET    /api/gists              # 获取 Gist 列表
POST   /api/gists              # 创建新 Gist
GET    /api/gists/:id          # 获取 Gist 详情
PUT    /api/gists/:id          # 更新 Gist
DELETE /api/gists/:id          # 删除 Gist
POST   /api/gists/:id/fork     # Fork Gist
POST   /api/gists/:id/star     # 收藏 Gist
GET    /api/gists/:id/raw/:filename  # 获取原始文件
GET    /api/gists/:id/export   # 导出为 ZIP

完整的 API 文档可在应用内访问 /api-docs 查看。

用户系统：安全可靠

注册与登录

安全的密码加密存储（bcrypt）
JWT 身份验证
Token 自动刷新机制

个人中心

自定义头像上传
密码修改
查看和管理所有 Gist
查看收藏列表

用户公开主页

每个用户都有专属的公开主页，展示所有公开的 Gist，方便分享和展示。

响应式设计 + 深色模式

全平台适配

无论是桌面端的大屏幕，还是移动端的小屏幕，Sify Gist 都能完美适配：

流畅的响应式布局
触控友好的交互设计
合理的信息密度调整

深色模式

内置深色模式支持：

自动跟随系统偏好
一键切换主题
护眼配色方案

适用场景

个人开发者

搭建个人代码知识库
收藏常用的代码片段
记录技术学习笔记
分享技术博客中的示例代码

团队协作

共享团队常用工具函数
沉淀项目最佳实践
快速分享调试代码
新人入门代码示例库

教育培训

教师分享课程示例代码
学生提交编程作业
代码点评和讲解
学习笔记整理

技术写作

博客文章代码展示
教程示例代码托管
技术文档代码片段
项目 Demo 演示

开源与社区

Sify Gist 是一个完全开源的项目，采用 MIT 许可证。

GitHub：https://github.com/santisify/sify-gist
问题反馈：欢迎提交 Issue
功能建议：期待你的 Pull Request

致谢

本项目受到 OpenGist 的启发。OpenGist 是一个优秀的自托管 Pastebin 解决方案，使用 Git 驱动。如果你需要更完整的、支持 Git 同步和 OAuth 登录的自托管方案，推荐使用 OpenGist。

未来规划

Sify Gist 仍在持续迭代中，计划中的功能包括：

📋 Markdown 文件渲染
🎨 代码主题自定义
🌍 多语言国际化
🔗 OAuth 第三方登录

立即体验：Demo 站点
项目地址：GitHub
作者：santisify

MC服务端打包（由客户端推导）

Wed, 25 Feb 2026 12:00:00 GMT

想要快速搭建Minecraft服务器却苦于繁琐的配置流程？ServerPackCreator正是您需要的解决方案。这款开源工具能够将Forge、Fabric、Quilt、LegacyFabric和NeoForge模组包一键转换为对应的服务器包，大幅简化服务器部署过程。

无论您是模组开发者、服务器管理员还是普通玩家，都能通过这款工具轻松创建专业级的Minecraft服务器环境。

为什么选择ServerPackCreator？

传统Minecraft服务器搭建需要手动处理大量配置文件和模组兼容性问题，而ServerPackCreator通过自动化流程彻底改变了这一现状。

您不再需要逐个检查模组兼容性、手动配置启动参数或担心版本冲突问题。该工具支持主流模组加载器，能够智能识别并排除客户端专用模组，确保生成的服务器包既完整又稳定。

快速上手

ServerPackCreator官方提供了三种使用方法，当然我们选择最简单的GUI。

安装ServerPackCreator

首先我们需要下载安装包,以下为安装包列表链接.根据个人的操作系统进行选择.

import { Card } from 'astro-pure/user'

<Card as='a' href='https://github.com/Griefed/ServerPackCreator/releases' heading='Griefed/ServerPackCreator' subheading='Create a server pack from a Minecraft Forge, NeoForge, Fabric, LegacyFabric or Quilt modpack!'

Click Me!!!

根据安装提示进行安装即可

服务端包制作

首先你需要使用MC启动器安装好需要打包的整合包的实例.

选择需要打包的整合包。
确认MC版本，模组加载器及版本。
生成服务包。

随即就会出现这个窗口,点击是就会跳转到对应的服务包

安装模组加载器服务端

我们需要到对应的模组加载器官网下载一个.jar文件，我么需要使用这个.jar文件构建服务端，此外我们也需要对应的java版本（可以去搜索一下）。这里我以neoforge为例

下载后放在之前打包好的服务端文件夹中。如下图所示：为了方便区分可以将上述图片中后缀为.bat, .sh, .ps1的文件删掉。现在需要下载服务端的包了，每个模组加载器的命令不一致需要参考加载器官方的使用文档。打开终端执行命令，这个步骤需要保证安装了java,终端打开打包好的服务端文件夹。执行一下命令：

java -jar ./neoforge-21.1.172-installer.jar --installServer

需要将neoforge-21.1.172-installer.jar换为自己对应的文件名称

执行完成后会发现有后缀为sh或bat的文件生成，现在新建一个文件命名为eula.txt，至于有什么用可以自己查询下官方的解释，内容为：

eula=true

如果你是windows系统可以直接双击.bat后缀的文件，linux系统在终端执行bash ./run.sh(run.sh 替换为实际名称)

问题解决

当然不可能是一帆风顺的，除非你运气好...... 每个人的问题都千奇百怪，那么就需要ai来帮我们解决问题了，在文件中打开logs将里面的latest.log文件内容发给ai,具体哪种算是报错呢？下面是无问题页面命令行底部有一个箭头或者有一个名称为Minecreaft Server的窗口即为正确。

部署

选择合适的服务器，如果是新手可以尝试使用面板安装。部署时只需要将无问题的服务端文件上传到服务器，最后执行上述生成的run.sh或run.bat文件即可。最后配置一下端口即可。

2025年度报告

Wed, 31 Dec 2025 23:00:00 GMT

2025年度报告

[toc]

随着2025年的结束，我想回顾一下这一年的成长、挑战和收获。这一年充满了技术探索、个人发展和对未来方向的思考。

一、技术发展

1.1 前端技术

2025年，我继续深入学习现代前端技术栈，特别是Astro框架的使用。通过构建和维护我的个人网站，我掌握了：

Astro静态站点生成
响应式设计和现代化UI组件
性能优化技巧
无障碍访问最佳实践

1.2 后端技术

在后端方面，我探索了多种技术：

Node.js和相关框架
数据库设计与优化
API设计与开发
微服务架构思想

1.3 工具与流程

版本控制：Git工作流程优化
自动化部署：CI/CD实践
代码质量：测试与代码审查

二、项目成果

优化了网站性能，减少了加载时间
增强了内容管理系统
改进了用户体验和可访问性

三、学习与成长

3.1 技术学习

深入学习了算法和数据结构
研究了设计模式和架构原则
探索了新技术趋势，如AI集成

3.2 软技能提升

沟通技巧的改进
团队协作能力
项目管理经验

四、挑战与克服

4.1 遇到的技术难题

性能优化挑战
跨浏览器兼容性问题
代码维护复杂性

4.2 解决方案

通过系统性调试和分析解决复杂问题
学习最佳实践并应用到项目中
建立了更完善的测试流程

五、展望2026

5.1 技术目标

深入学习AI和机器学习技术
探索新的前端框架和工具
提高系统架构设计能力

5.2 项目计划

开发更多实用的工具
优化现有项目
尝试新的项目类型

5.3 个人发展

继续提升软技能
扩展技术视野
建立更广泛的行业联系

六、结语

2025年是充满挑战和机遇的一年。我学到了很多，成长了很多，也意识到还有很多需要学习和改进的地方。期待2026年能继续在技术道路上前行，创造更多有价值的东西。

PixelPunk:一键部署你的私有文件管理平台

Wed, 03 Dec 2025 15:00:00 GMT

📁 私有文件管理平台 PixelPunk

✨ 项目简介

今天，我要向大家推荐一个令人惊艳的开源项目 —— PixelPunk！这是一个功能强大、设计优雅的私有文件管理与分享平台，集成了文件上传下载、AI 智能分析、向量搜索等多种现代功能。项目采用 Go 语言开发，性能出色、部署便捷，是搭建个人或团队私有云存储的理想选择。

🎯 为什么选择 PixelPunk？

| 特点 | 说明 | | ------------ | -------------------------------------------------- | | 功能丰富 | 不止是文件存储，还集成 AI 分析、向量搜索等高级特性 | | 界面现代 | 简洁美观的前端设计，提供流畅的用户交互体验 | | 部署轻松 | 支持一键部署，快速搭建私有化环境 | | 安全可靠 | 数据完全自主掌控，支持私有化部署，保障隐私安全 | | 扩展灵活 | 支持多种数据库、存储后端，便于按需定制 |

🏗️ 技术架构

PixelPunk 采用了前后端分离的现代化架构设计：

| 组件 | 技术选型 | | -------------- | --------------------------------------- | | 后端服务 | Go + Gin 框架 | | 数据库 | PostgreSQL / MySQL / SQLite（多选支持） | | 向量数据库 | Qdrant（用于 AI 向量搜索） | | 前端界面 | Vue 3 + Vite + TypeScript | | 缓存服务 | Redis | | 文件存储 | 本地存储 / 云存储（S3 兼容） |

🚀 一键部署体验

我亲自部署过，整个过程非常顺畅！只需执行以下命令，即可快速启动服务：

# 使用在线脚本一键部署
curl -fsSL https://raw.githubusercontent.com/CooperJiang/PixelPunk/main/scripts/deploy/deploy.sh | bash

或者，也可以先克隆项目再手动部署：

git clone https://github.com/CooperJiang/PixelPunk.git
cd PixelPunk
bash scripts/deploy/deploy.sh

部署脚本会自动完成以下工作：

📦 拉取最新代码和依赖
⚙️ 生成并配置环境变量
🐳 启动数据库、缓存、向量库等服务
🚀 运行前后端应用
🗃️ 初始化数据库和索引

完成后，访问 http://localhost:8080（默认端口）即可进入平台。

💡 提示：若需修改端口或配置域名，可在部署前调整环境变量。

🧩 核心功能体验

📂 文件管理

直观的树形文件浏览器
拖拽上传、批量操作
文件标签、分类管理
版本控制与历史记录

🤖 AI 智能分析

文件内容自动解析与摘要
智能标签生成与分类
图像内容识别（EXIF、场景识别）
文档内容提取（PDF、Word、文本）

🔍 向量搜索

基于 Qdrant 的语义向量搜索
相似文件智能推荐
多模态搜索（文本、图像混合检索）

📝 部署建议

服务器配置

最低推荐：2 核 CPU / 4 GB 内存
生产环境建议：4 核 CPU / 8 GB 内存或更高

域名与安全

建议绑定域名并配置 HTTPS（Let's Encrypt 免费证书）
配置防火墙规则，限制不必要的端口访问

数据备份

定期备份数据库（可使用 pg_dump 或 mysqldump）
文件存储目录建议同步至云存储或进行异地备份

性能调优

根据使用情况调整 Gin 的并发参数
合理配置 Redis 缓存策略，提升响应速度

💭 使用心得

亲自体验下来，PixelPunk 给我留下了深刻印象：

部署过程十分顺畅，几乎无门槛
界面设计简洁而不失现代感，交互流畅
AI 分析功能实用，能大幅提升文件管理效率
向量搜索响应迅速，准确率高

特别适合需要安全、私有、智能的文件管理场景，如团队文档协作、个人知识库、多媒体资产管理等。

🎉 总结

如果你正在寻找一个功能全面、界面美观、部署简单的私有文件管理平台，PixelPunk 绝对值得你尝试。它既满足了基础的文件存储需求，又融入了 AI 智能与向量搜索等前沿特性，是构建现代化私有云存储的优秀选择。

快去试试吧！相信它也会成为你的心头好～

🌐 项目地址：https://github.com/CooperJiang/PixelPunk 📚 详细文档：项目文档 🌐 站长部署地址：https://pixel.santisify.top

本文由实际部署体验编写，内容基于 PixelPunk 最新版本。 如有疑问或建议，欢迎在 GitHub 仓库提出 Issue 或参与讨论。

十年火线，青春不散—致十年CFM岁月

Fri, 07 Nov 2025 21:00:00 GMT

初遇火线，热血依旧

十年成长，见证变迁

友情与青春的见证

十周年，我们的荣耀时刻

致未来，火线情不散

AtCoder Beginner Contest 430

Sat, 01 Nov 2025 20:00:00 GMT

A Candy Cookie Law

题目描述

给四个数字$A$, $B$, $C$, $D$, 若 $C \ge A$的同时 $D \ge B$,输出 $No$.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int a, b, c, d;
    std::cin >> a >> b >> c >> d;
    if ((c >= a && d >= b) || c < a) {
        std::cout << "No" << std::endl;
    } else {
        std::cout << "Yes" << std::endl;
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    // std::cin >> T;
    while (T --) solve();
    return 0;
}

B Count Subgrid

题目描述

$N \times N$ 的矩阵中包含多少种不同的 $M \times M$ 的子矩阵.

解题思路

遍历矩阵，将每个子矩阵都转化为字符串存入 $map$，$map$ 大小即为答案.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::map<std::string, int> mp;;
    std::vector<std::string> a(n);
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i];
    }
    for (int i = 0; i < n - m + 1; i ++) {
        for (int j = 0; j < n - m + 1; j ++) {
            std::string s = "";
            for (int l = 0; l < m; l ++) {
                for (int r = 0; r < m; r ++) {
                    s += a[i + l][j + r];
                }
            }
            mp[s] ++;
        }
    }
    std::cout << mp.size() << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    // std::cin >> T;
    while (T --) solve();
    return 0;
}

C Truck Driver

题目描述

一个字符串 $S$ 中存在多少个数对$[l, r]$，使得这个子串($S_{l}, S_{l+1} \cdots S_{r}$),满足字符 $a$ 个数 $ct_a \ge A$, 字符 $b$ 个数 $ct_b < B$

解题思路

数据范围不允许使用暴力，那么只能使用二分，循环左边，二分右区间，二分条件就是$ct_a \ge A, ct_b < B$,但是我们不能直接一个二分查找，可以想到在一个区间内可能存在多个满足条件的值. 我们只有分别二分满足$ct_a=A, ct_b=B$的位置 $la, lb$，然后去取得两个的交集，其中，$lb$ 是有可能小于 $la$ 的.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n, a, b;
    std::cin >> n >> a >> b;
    std::string s;
    std::cin >> s;
    std::vector<int> ct1(n + 1, 0), ct2(n + 1, 0);
    for (int i = 0; i < n; i ++) {
        ct1[i + 1] = ct1[i] + (s[i] == 'a');
        ct2[i + 1] = ct2[i] + (s[i] == 'b');
    }
    int ans = 0;
    for (int i = 0; i < n; i ++) {
        int l = i, r = n + 1, ll = i, rr = n + 1;
        while (std::abs(l - r) > 1) {
            int mid = (l + r) >> 1;
            if (ct1[mid] - ct1[i] >= a) r = mid;
            else l = mid;
        }
        while (std::abs(ll - rr) > 1) {
            int mid = (ll + rr) >> 1;
            if (ct2[mid] - ct2[i] < b) ll = mid;
            else rr = mid;
        }
        ans += std::max(rr - r, 0ll);
    }

    std::cout << ans << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int T = 1;
    // std::cin >> T;
    while (T --) solve();
    return 0;
}

Vue学习笔记（三）

Fri, 24 Oct 2025 21:00:00 GMT

Vue 内置组件学习笔记（核心组件实战整理）

一、＜component＞：动态组件切换

核心作用

通过 is 属性动态渲染不同组件，实现无刷新切换页面 / 功能模块，提升组件复用性。

核心属性

is：指定要渲染的组件（值为组件名字符串或组件对象）。

实战案例（Tab 标签页）

<template>
  <div>
    <button @click="currentComponent = 'Home'">首页</button>
    <button @click="currentComponent = 'List'">列表页</button>
    <!-- 动态渲染组件 -->
    <component :is="currentComponent"></component>
  </div>
</template>

<script setup>
import { ref } from 'vue'

import Home from './Home.vue'
import List from './List.vue'

const currentComponent = ref('Home') // 初始渲染 Home 组件
</script>

常见误区

is 的值需与组件名完全匹配（区分大小写，建议使用 PascalCase 命名组件）。
动态组件外若嵌套 <keep-alive>，需确保 <component> 是直接子元素，否则缓存失效。

二、＜keep-alive＞：组件缓存管理

核心作用

缓存不活动的组件实例（而非销毁），保留组件状态（如表单输入、滚动位置），减少重复渲染。

核心属性

include：仅缓存名称匹配的组件（值为字符串、正则或数组，匹配组件 name 属性）。
exclude：不缓存名称匹配的组件（规则同上）。
max：最多缓存的组件实例数量（超出则销毁最早缓存的实例）。

实战案例（缓存 Tab 页数据）

<template>
  <div>
    <button @click="currentComponent = 'UserForm'">用户表单</button>
    <button @click="currentComponent = 'LogList'">日志列表</button>
    <!-- 只缓存 UserForm 组件 -->
    <keep-alive include="UserForm">
      <component :is="currentComponent"></component>
    </keep-alive>
  </div>
</template>

<script setup>
import { ref } from 'vue'

import LogList from './LogList.vue'
import UserForm from './UserForm.vue' // 组件名需设置为 UserForm

const currentComponent = ref('UserForm')
</script>

注意事项

缓存的组件不会触发 created/mounted 等生命周期，需用 activated（激活时）、deactivated（失活时）替代。
若组件无 name 属性，include/exclude 需匹配组件文件名（不推荐，建议显式定义 name）。

三、＜slot＞：组件内容分发（插槽）

核心作用

允许父组件向子组件传递自定义内容，实现组件的灵活扩展（如卡片头部、列表项操作按钮）。

三种用法及案例

1. 默认插槽（无名称）

子组件接收父组件传递的默认内容：

<!-- 子组件 Card.vue -->
<template>
  <div class="card">
    <slot></slot>
    <!-- 父组件内容会插入这里 -->
  </div>
</template>

<!-- 父组件使用 -->
<Card>
  <p>这是卡片的默认内容</p> <!-- 会被插入到子组件的 <slot> 中 -->
</Card>

2. 具名插槽（指定名称）

子组件定义多个命名插槽，父组件按需传递内容：

<!-- 子组件 Card.vue -->
<template>
  <div class="card">
    <slot name="header"></slot>
    <!-- 头部插槽 -->
    <slot></slot>
    <!-- 默认插槽 -->
    <slot name="footer"></slot>
    <!-- 底部插槽 -->
  </div>
</template>

<!-- 父组件使用（Vue3 简写 # 替代 v-slot:） -->
<Card>
  <template #header>
    <h3>卡片标题</h3> <!-- 插入 header 插槽 -->
  </template>
  <p>卡片正文内容</p> <!-- 插入默认插槽 -->
  <template #footer>
    <button>提交</button> <!-- 插入 footer 插槽 -->
  </template>
</Card>

3. 作用域插槽（子传父数据）

子组件向父组件传递数据，父组件基于数据自定义渲染：

<!-- 子组件 List.vue -->
<template>
  <ul>
    <li v-for="item in list" :key="item.id">
      <!-- 向父组件传递 item 数据 -->
      <slot :item="item" :index="index"></slot>
    </li>
  </ul>
</template>

<script setup>
const list = [
  { id: 1, name: '张三' },
  { id: 2, name: '李四' }
]
</script>

<!-- 父组件使用 -->
<List>
  <!-- 接收子组件传递的 item 数据，自定义渲染列表项 -->
  <template #default="slotProps">
    <span>{{ slotProps.index + 1 }}. {{ slotProps.item.name }}</span>
    <button @click="edit(slotProps.item)">编辑</button>
  </template>
</List>

关键技巧

Vue3 中具名插槽可用 #插槽名 简写（如 #header 替代 v-slot:header）。
作用域插槽的参数可解构简化（如 #default="{ item, index }"）。

四、＜transition＞与＜transition-group＞：过渡动画

核心作用

为组件 / 元素的插入、更新、移除添加过渡动画，提升用户体验。

1. ＜transition＞：单个元素 / 组件过渡

<template>
  <button @click="show = !show">切换</button>
  <!-- 为 p 标签添加过渡动画 -->
  <transition name="fade">
    <p v-if="show">这是一段文本</p>
  </transition>
</template>

<style>
/* 进入/离开的过渡状态 */
.fade-enter-active,
.fade-leave-active {
  transition: opacity 0.5s ease;
}
/* 进入开始/离开结束的状态 */
.fade-enter-from,
.fade-leave-to {
  opacity: 0;
}
</style>

<script setup>
import { ref } from 'vue'

const show = ref(true)
</script>

2. ＜transition-group＞：列表过渡（多个元素）

<template>
  <button @click="addItem">添加项</button>
  <!-- 为列表项添加过渡 -->
  <transition-group name="slide" tag="ul">
    <li v-for="item in list" :key="item.id">
      {{ item.name }}
    </li>
  </transition-group>
</template>

<style>
.slide-enter-active,
.slide-leave-active {
  transition: transform 0.3s ease;
}
.slide-enter-from {
  transform: translateX(30px);
  opacity: 0;
}
.slide-leave-to {
  transform: translateX(-30px);
  opacity: 0;
}
</style>

核心属性

name：定义过渡类名前缀（如 name="fade" 对应类名 fade-enter-active）。
tag（仅 transition-group）：指定渲染的容器标签（默认 <span>）。

五、综合实战要点

组件组合：＜component＞ + ＜keep-alive＞ 实现带缓存的页面切换，＜slot＞ 实现组件个性化扩展（如后台管理系统的动态页面 + 自定义操作区）。
问题解决：

缓存组件数据刷新：在 activated 钩子中手动更新数据。
插槽数据传递错误：检查作用域插槽的参数名是否与子组件一致。

学习优先级：先掌握 ＜component＞ ＜keep-alive＞ ＜slot＞（日常开发高频使用），再深入 ＜transition＞ 动画细节。

AtCoder Beginner Contest 425

Tue, 14 Oct 2025 10:00:00 GMT

A Sigma Cubes

题目描述

输入$N$,计算$\sum_{i=1}^N (-1)^i \times i^3$

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
	int n;
	std::cin >> n;
	int res = 0;
	for(int i = 1; i <= n; i ++) {
		if(i & 1) res -= i * i * i;
		else res += i * i * i;
	}

	std::cout << res << std::endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
  solve();
}

B Find Permutation 2

题目描述

给出数组 $A$, 判断是否存在一个排列 $P$ 使得满足:

$P$是一个排列。
$P_{i}=A_{i}(A_{i} \neq -1)$, $P{i} = R (A_{i} = -1)$

解题思路

首先记录下 $A$ 中非 $-1$ 的其他数的个数记为 $ct$,若$ct_{i} \ge 2$ 则不可能有合法的 $P$ 将 $ct_{i}$ 为 $0$ 的依次填入$A_{i}=-1$ 处即可获得排列 $P$.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> a(n + 1, 0), b(n + 1, 0);
	for(int i = 1; i <= n; i ++) {
		std::cin >> b[i];
		if(b[i] != -1) {
			a[b[i]] ++;
		}
	}

	for(int i = 1; i <= n; i ++) {
		if(a[i] > 1) {
			std::cout << "No" << std::endl;
			return;
		}
	}
	std::cout << "Yes" << std::endl;
	std::queue<int> q;
	for(int i = 1; i <= n; i ++) {
		if(!a[i]) {
			q.push(i);
		}
	}
	for(int i = 1; i <= n; i ++) {
		if(b[i] == -1) {
			std::cout << q.front() << ' ';
			q.pop();
		}else {
			std::cout << b[i] << ' ';
		}
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
  solve();
}

C Rotate and Sum Query

题目描述

给出数组 $A$ 和$q$次查询,每次查询如下:

$1$ $c$: 循环 $c$ 次，每次循环都将 $A_{1}$ 放在数组末尾.
$2$ $l$ $r$: 查询区间$[l, r]$的总和

数据范围：

$1\le N\le 2\times 10^5$
$1\le Q\le 2\times 10^5$
$1\le A_i \le 10^9$
$1\le c\le N$
$1\le l\le r \le N$

解题思路

可以发现数据范围较大，无法使用rotate去模拟，但是可以发现每次循环次数 $ct$ 到达 $n$ 后就会回到初始数组，区间总和也只与$ct % n$有关. 我们可以使用变化后的区间 $[l, r]$ 和 $ct$ 去找变化前的区间 $[x, y]$,可以发现需要预处理前缀和 $s$. 但是变化前的区间可能会出现 $x > y$，这个区间$[y, x]$的值则是区间外的总和.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
	int n, q;
	std::cin >> n >> q;
	std::vector<int> s(n + 1, 0), a(n + 1, 0);
	for (int i = 0; i < n; i++) {
		std::cin >> a[i];
		s[i] = a[i];
		if (i) s[i] = s[i - 1] + a[i];
	}
	int t, x, y, ct = 0;
	while (q--) {
		std::cin >> t >> x;
		if (t == 1) {
			ct += x;
		} else {
			std::cin >> y;
			x = (x - 1 + ct) % n;
			y = (y - 1 + ct) % n;
			if (x > y) {
				std::cout << s[y] + s[n - 1] - (x ? s[x - 1] : 0) << std::endl;
			} else {
				std::cout << s[y] - (x ? s[x - 1] : 0) << std::endl;
			}
		}
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
}

AtCoder Beginner Contest 424

Sat, 20 Sep 2025 20:00:00 GMT

A Isosceles

题目描述

给出三角形的三个边$a$, $b$, $c$，判断三角形是否为等腰三角形。

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int a, b, c;
    std::cin >> a >> b >> c;
    if (a == b || a == c || b == c) {
        std::cout << "Yes" << std::endl;
    } else {
        std::cout << "No" << std::endl;
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int _ = 1;
    // std::cin >> _;
    while (_ --) solve();
}

B Perfect

题目描述

$n$个人，$m$个题，总共$k$次提交，每次提交都是第$A_{i}$人完成第$B_{i}$题。输出完成所有题的人的编号，有多个按最后一个题的完成顺序输出。

解题思路

直接统计完成题的数目，当数目达到$m$时，直接输出编号。

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;
    std::vector<int> a(n + 1, 0);
    while (k --) {
        int x, y;
        std::cin >> x >> y;
        a[x] ++;
        if (a[x] == m) {
            std::cout << x << ' ';
        }
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int _ = 1;
    // std::cin >> _;
    while (_ --) solve();
}

C New Skill Acquired

题目描述

$n$个数对，数对${A_{i}, B_{i}}$表示到达点$A_{i}$或者$B_{i}$才可到达点$i$（即$A_{i} \rightarrow i，B_{i} \rightarrow i$）,$A_{i} = 0$ $B_{i} = 0$表示$i$点可直接到达. 问：最多能到达多少个点。

解题思路

题目描述很明了，直接建图，再$dfs$或$bfs$搜索即可.

参考代码

bfs

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n;
    std::cin >> n;
    std::queue<int> q;
    std::vector<bool> vis(n + 1, false);
    std::vector g(n + 1, std::vector<int>());
    for (int i = 0, x, y; i < n; i ++) {
        std::cin >> x >> y;
        if (!x) {
            q.push(i + 1);
            vis[i + 1] = true;
        }
        g[x].push_back(i + 1), g[y].push_back(i + 1);
    }
    while (!q.empty()) {
        auto u = q.front();
        q.pop();
        for (auto v: g[u]) {
            if (!vis[v]) vis[v] = true, q.push(v);
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        ans += vis[i];
    }

    std::cout << ans << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int _ = 1;
    // std::cin >> _;
    while (_ --) solve();
}

D 2x2 Erasing 2

题目描述

给定$n * m$的矩阵，要求修改矩阵，使得不出现$2 * 2$的 '#' 的矩阵。输出最小操作数。

解题思路

可以发现数据最大为 $100$ 组 $7 * 7$ 的矩阵，可以直接暴力$dfs$.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
	int n, m;
	std::cin >> n >> m;
	std::vector<std::string> s(n);
	for (int i = 0; i < n; i++) std::cin >> s[i];
	int ans = 1e9;
	std::function<void(int, int, int)> dfs = ([&](int x, int y, int res) {
		if (res >= ans) return; //实测不添加等号会TLE
		if (y == m) {
			y = 0, x++;
		}
		if (x == n) {
			ans = res;
			return;
		}

		if (s[x][y] == '.') {
			dfs(x, y + 1, res);
			return;
		} else {
			if (x == 0 || y == 0 || s[x - 1][y] == '.' || s[x][y - 1] == '.' || s[x - 1][y - 1] == '.')
				dfs(x, y + 1, res);
			s[x][y] = '.';
			dfs(x, y + 1, res + 1);
			s[x][y] = '#';
		}
	});
	dfs(0, 0, 0);
	std::cout << ans << std::endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int _ = 1;
	std::cin >> _;
	while (_--) solve();
}

Educational Codeforces Round 182 (div2)

Tue, 16 Sep 2025 14:00:00 GMT

A Cut the Array

Cut the Array

题目描述

给定数组 $A$, 需要输出满足以下的 $l$ , $r$ ：

$$s_{1} = \sum^{l}{i=1}A{i} \ Mod\ 3$$

$$s_{2} = \sum^{r}{i=l + 1}A{i} \ Mod\ 3$$

$$s_{3} = \sum^{n}{i=r + 1}A{i} \ Mod\ 3$$

$s_{1}$, $s_{2}$, $s_{3}$ 互不相同或者都相同。若不存在输出 $0 \ 0$

解题思路

由于 $n$ 的数据范围较小，我们可以直接枚举每个 $l$ , $r$，满足条件直接输出即可.

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1), s(n + 1, 0);
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i + 1];
        s[i + 1] = s[i] + a[i + 1];
    }

    for (int l = 1; l < n; l ++) {
        for (int r = l + 1; r < n; r ++) {
            int s1 = s[l], s2 = s[r] - s[l], s3 = s[n] - s[r];
            if (s1 % 3 == s2 % 3 && s2 % 3 == s3 % 3) {
                std::cout << l << ' ' << r << std::endl;
                return;
            }
            if (s1 % 3 != s2 % 3 && s1 % 3 != s3 % 3 && s2 % 3 != s3 % 3) {
                std::cout << l << ' ' << r << std::endl;
                return;
            }
        }
    }
    std::cout << "0 0" << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin . tie(nullptr), std::cout . tie(nullptr);
    int ___ = 1;
    std::cin >> ___;
    while (___ --) solve();
}

B Maximum Cost Permutation

Maximum Cost Permutation

题目描述

给定一个长度为 $n$ 的数组, 数组中的数都为非负整数，并且正整数不重复，现在将数组中的 $0$ 替换为正整数，并且与已有的不重复。

现定义代价为：将这个数组变为递增的数组，所操作的区间大小。

输出最大的代价

解题思路

我们可以发现要想要代价最大就需要将数组尽可能的变为递减的数组，那么就可以将尽可能大的数放在前面，这样就可以使得代价最大

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n), ct(n + 1, 0), q;
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i];
        ct[a[i]] ++;
    }

    for (int i = 1; i <= n; i ++) {
        if (ct[i] == 0) q.push_back(i);
    }
    std::reverse(q.begin(), q.end());
    int opt = 0;
    for (int i = 0; i < n; i ++) {
        if (a[i] == 0) {
            a[i] = q[opt ++];
        }
    }
    int l = 0, r = n - 1;
    while (a[l] == l + 1 && l + 1 < n) l ++;
    while (a[r] == r + 1 && r >= 0) r --;

    if (l > r) {
        std::cout << 0 << std::endl;
    } else {
        std::cout << r - l + 1 << std::endl;
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int ___ = 1;
    std::cin >> ___;
    while (___ --) solve();
}

C Non-Descending Arrays

Non-Descending Arrays

题目描述

两个数组 $a$, $b$。你可以选择一些下标 $i$，使得这些下标对应的位置交换。最后要使得两个数组都是升序。求方案数。

解题思路

显然只有交换和不交换两个状态。那么记 $dp[i][0/1]$ 表示第个位置交换/不交换使得前缀升序的方案数，那么考虑 $i - 1$ 交不交换，看两个位置是否合法。

参考代码

代码省略取模类可参考jly算法模板，当然也可以选择边加边模

#include<bits/stdc++.h>
// 此处放置取模类

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1), b(n + 1);
    std::vector dp(n + 1, std::array<Z, 2>{});

    for (int i = 0; i < n; i ++) std::cin >> a[i + 1];
    for (int i = 0; i < n; i ++) std::cin >> b[i + 1];
    dp[1][0] = 1;
    dp[1][1] = 1;
    for (int i = 1; i <= n; i ++) {
        if (a[i] >= a[i - 1] && b[i] >= b[i - 1]) {
            dp[i][0] += dp[i - 1][0];
            dp[i][1] += dp[i - 1][1];
        }
        if (a[i] >= b[i - 1] && b[i] >= a[i - 1]) {
            dp[i][0] += dp[i - 1][1];
            dp[i][1] += dp[i - 1][0];
        }
    }
    std::cout << dp[n][1] + dp[n][0] << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int _ = 1;
    std::cin >> _;
    while (_ --) solve();
}

D Price Tags

Price Tags

题目描述

一个数组 $a$，和一个正整数 $y$ ，将数组的每个数都变为 $\lceil\frac{a_{i}}{x}\rceil$。

代价为: 将变化后与变化前出现相同的数逐个删除，剩余的数的个数 $w$, 变化后的数组 $a$ 的总和$s$，计算 $w \times y + s$ 的最大值。

解题思路

由于数组元素都是向上取整，可以发现，在一个区间 $[(x-1)*m+1, x * m]$ 在做运算后都是 $m$，那么我们就可以对 $a$ 数组进行区间处理。

记 $ma$ 为 $a$ 中最大值，那么对于一个 $x$，所有数操作后的值域都在 $[1, \frac{ma}{x}]$ 之间，那么考虑枚举 $x$，对于一个值 $j$，除 $x$ 向上取整后会变成的数的范围为 $[(j - 1)x+1, jx]$，用前缀和记录这个范围原本有多少数，就可以得到和原本 $j$ 的个数的差异。最后计算出答案即可

参考代码

#include<bits/stdc++.h>

#define int long long
#define pii std::pair<int,int>

void solve() {
    int n, c, ma = -1e8;
    std::cin >> n >> c;
    std::vector<int> a(n), ct(200005, 0);
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i];
        ct[a[i]] ++;
        ma = std::max(ma, a[i]);
    }

    if (ma == 1) {
        std::cout << n << std::endl;
        return;
    }

    auto s = ct;
    for (int i = 1; i < 200005; i ++) {
        s[i] += s[i - 1];
    }

    int ans = -1e18;
    for (int x = 2; x <= ma; x ++) {
        int m = (ma + x - 1) / x;
        int res = 0;
        for (int j = 1; j <= m; j ++) {
            int l = (j - 1) * x + 1, r = std::min(ma, j * x);
            if (l > ma) {
                break;
            }
            int w = s[r] - s[l - 1];
            res += w * j;
            res -= c * std::max(0ll, w - ct[j]);
        }
        ans = std::max(res, ans);
    }

    std::cout << ans << std::endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int _ = 1;
    std::cin >> _;
    while (_ --) solve();
}

Codeforces Round 1042 (Div. 3)

Fri, 29 Aug 2025 20:00:00 GMT

A Lever

题目描述

给定两个长度为 $n$ 的数组 $A$,$B$ .现在有以下两个操作：

选择一个下标 $i$ ,若$A_{i}>B_{i}$，则$A_{i}=A_{i}-1$. 如果不存在这样的$i$，则忽略此步骤.

选择一个下标 $i$ ,若$A_{i}<B_{i}$，则$A_{i}=A_{i}+1$. 如果不存在这样的$i$，则忽略此步骤. 当执行完第二步都会检查第一步是否执行，若未执行则直接结束。问：迭代的次数是多少？

解题思路

可以发现两个操作都是操作 $A$ 数组，$B$ 数组没有变化过。既然这样，我们就可以只考虑 $A_{i}$和$B_{i}$ 的大小关系. 不懂的，可以看样例1.

参考代码

void solve() {
    int n;
    std::cin >> n;
    int ans = 1;
    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
       std::cin >> a[i];
    }
    for (int i = 0, x; i < n; i++) {
       std::cin >> x;
       if (a[i] > x) ans += a[i] - x;
    }
    std::cout << ans << std::endl;
}

B Alternating Series

题目描述

构造一个数组 $A$,使得数组 $A(|A_{1}|,|A_{2}|,\cdots,|A_{n}|)$的字典序最下,并且长度大于等于$2$的子数组的和为正数。

解题思路

可以发现奇数位可以先填$-1$,这样可以保证字典序最小,依次考虑偶数位,由于前后都是$-1$,且要保证和大于等于$2$,那么偶数位只能填$3$.虽然这样填可以满足和为正数,但是会有个新的问题,不能保证字典序最小.

例如$6$的构造：${-1,3,-1,3,-1，3}$，当取第$5$，$6$位的长度为$2$的子数组${-1,3}$就会发现，最后一位可以为$2$，依次可以推理出：当长度为偶数，那么最后一位应该为$2$。

参考代码

void solve() {
    int n;
    std::cin >> n;
    for (int i = 0; i < n; i++) {
       if (i % 2 == 0) {
          std::cout << -1 << ' ';
       } else if (i == n - 1) {
          std::cout << 2 << "\n";
       } else {
          std::cout << 3 << ' ';
       }
    }
}

C Make it Equal

题目描述

给出两个数组$S$, $T$，我们可以对$S$进行任意次以下操作：将$S_{i}$修改为$S_{i}+k$或者$|S_{i}-k|$. 是否可以将$S$变为$T$?

解题思路

由于变化的大小都是$k$，则可以看作$S_{i} + t * k = T_{j} (t \in Z)$ 那么我们可以将$S$和$T$都对$k$取余,但是可能出现$S_{i} = k - T_{i}$,我们可以将小于等于$\frac{k}{2}$的数做一个变形,变为$k-S_{i}$或者$k-T_{i}$,最后再排序,检查是否相同.

参考代码

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n), b(n);
    for (int i = 0; i < n; i++) {
       std::cin >> a[i];
       a[i] %= k;
       if (a[i] <= k / 2) {
          a[i] = k - a[i];
       }
    }
    for (int i = 0; i < n; i++) {
       std::cin >> b[i];
       b[i] %= k;
       if (b[i] <= k / 2) {
          b[i] = k - b[i];
       }
    }
    std::sort(a.begin(), a.end());
    std::sort(b.begin(), b.end());
    std::cout << (a == b ? "YES" : "NO") << std::endl;
}

D Arboris Contractio

题目描述

选择一条简单路径$s\to t$，然后将路径上除了$s$以外的所有点都直接连接到$s$上（即变成s的直连儿子）。即每次操作实际上是将一条路径“收缩”到起点$s$，使得路径上的所有点都直接连到$s$。这样，操作后从s到路径上任意一点的距离都变为$1$（除了$s$自己），而原来路径上的分支结构被改变。最小化直径，并求达到最小直径所需的最少操作次数。

解题思路

最终树是双星结构（有两个中心相邻）。我们需要选择一条边（u,v）作为中心边，使得u和v覆盖的叶子数最多（即u的叶子邻居数+v的叶子邻居数，注意如果u是叶子则包括自己，v同理）。那么，最少操作次数就是总叶子数减去最大覆盖叶子数（即leaf - ans）。因为已经覆盖的叶子不需要操作（它们已经直接连接到中心），而未覆盖的叶子每个都需要一次操作来提升（将它直接连接到某个中心）。

参考代码

void solve() {
    int n;
    std::cin >> n;
    std::vector g(n + 1, std::vector<int>());
    for (int i = 0, u, v; i < n - 1; i++) {
       std::cin >> u >> v;
       g[u].push_back(v);
       g[v].push_back(u);
    }
    int leaf = 0, ans = 0;
    for (int i = 1; i <= n; i++) {
       if (g[i].size() == 1) leaf++;
       int res = (g[i].size() == 1);
       for (auto v : g[i]) {
          res += (g[v].size() == 1);
       }
       ans = std::max(res, ans);
    }
    std::cout << leaf - ans << std::endl;
}

2025省赛预选赛补题

Sun, 27 Apr 2025 00:00:00 GMT

(cf补题链接)[https://codeforces.com/gym/606649]

H

题目描述

给定三个数组$A$, $B$, $C$,长度分别为 $n$, $m$, $p$,每个数组取一个数求和，输出前$k$个最大值。

数据范围： $l \le n,m,p \le 1000$, $1 \le k \le min(3000, n \times m \times p)$ , $0 \le A_{i}, B_{i}, C_{i} \le 10000000000$

解题思路

首先想到的最简单的思路是暴力求解，这样的时间复杂度将会是$1e^{9} \log_{2} ^{1e^{9}}$ ，如何优化呢？
我们可以将其中两个数组合并，这里我们选择将$A, B$ 两个数组合并，然后进行排序，这里复杂度为$1e^{6}\log_{2}^{1e^{6}}$, 我么选择合并后的前$k$个最大值和数组$C$合并，这里的复杂度为$3e^{3} \times 1e^{3}$, 可以用堆维护$k$个数。

参考代码

#include<bits/stdc++.h>

using i128 = __int128;
#define endl '\n'
#define int long long
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
  int n, m, p, k;
  std::cin >> n >> m >> p >> k;
  std::vector<int> a(n), b(m), c(p);
  for(int i = 0; i < n; i++) std::cin >> a[i];
  for(int i = 0; i < m; i++) std::cin >> b[i];
  for(int i = 0; i < p; i++) std::cin >> c[i];
  std::vector<int> ab;
  for(int i = 0; i < n; i++) {
   for(int j = 0; j < m; j++) {
    ab.push_back(a[i] + b[j]);
   }
  }
  std::sort(ab.begin(), ab.end(), std::greater<>());
  std::sort(c.begin(), c.end(), std::greater<>());
  std::priority_queue<int, std::vector<int>, std::greater<> > pq;
  for(int i = 0; i < std::min(k, (int) ab.size()); i++) {
   for(int j = 0; j < p; j++) {
    int t = ab[i] + c[j];
    if (pq.size() == k) {
     auto w = pq.top();
     if (w < t) {
      pq.pop();
      pq.push(t);
     }
    } else {
     pq.push(t);
    }
   }
  }
  std::vector<int> res;
  while (!pq.empty()) {
   res.push_back(pq.top());
   pq.pop();
  }
  std::reverse(res.begin(), res.end());
  for(auto i : res) {
   std::cout << i << endl;
  }
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
  solve();
  return 0;
}

E

题目描述

给定一个长度为$n$的数组$A$, 有$q$次询问,每次给出$l, r, start, end$, 对于每次询问，我们要输出$A$中在区间段$[l,r]$ 中,$start \le A_{i} \le end$的数的个数。

数据范围：$1 \le N, q \le 10^{5}, -10^{12} \le A_{i} \le 10^{12}$

解题思路

赛时，我想的是对区间内的数排序,然后二分查找边界,计算数量,奈何TLE,tql,显然是排序超时了。
正解是树状数组或者线段树

参考代码

#include<bits/stdc++.h>

using i128 = __int128;
#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;
std::mt19937_64 rng(std::chrono::system_clock::now().time_since_epoch().count());
std::vector<int> a(MAX_N);
struct Node {
  int l{}, r{};
  std::vector<int> sorted;
};

Node tr[4 * MAX_N];

void build(int u, int l, int r) {
  tr[u].l = l;
  tr[u].r = r;
  tr[u].sorted.clear();
  if (l == r) {
   tr[u].sorted.push_back(a[l]);
   return;
  }
  int mid = (l + r) / 2;
  build(u << 1, l, mid);
  build(u << 1 | 1, mid + 1, r);
  auto &left = tr[u << 1].sorted;
  auto &right = tr[u << 1 | 1].sorted;
  tr[u].sorted.resize(left.size() + right.size());
  merge(left.begin(), left.end(), right.begin(), right.end(), tr[u].sorted.begin());
}

int query(int u, int l, int r, int start, int end) {
  if (tr[u].r < l || tr[u].l > r) {
   return 0;
  }
  if (l <= tr[u].l && tr[u].r <= r) {
   auto &v = tr[u].sorted;
   int left_pos = lower_bound(v.begin(), v.end(), start) - v.begin();
   int right_pos = upper_bound(v.begin(), v.end(), end) - v.begin();
   return right_pos - left_pos;
  }
  return query(u << 1, l, r, start, end) + query(u << 1 | 1, l, r, start, end);
}

void solve() {
  int N, Q;
  std::cin >> N >> Q;
  for(int i = 1; i <= N; ++i) {
   std::cin >> a[i];
  }
  build(1, 1, N);
  while (Q--) {
   int l, r, s, e;
   std::cin >> l >> r >> s >> e;
   std::cout << query(1, l, r, s, e) << endl;
  }
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
  solve();
  return 0;
}

Restful API Tips

Fri, 21 Mar 2025 16:36:32 GMT

API请求

HTTP动词

GET:     读取（READ）
POST:    新建（CREATE）
PUT:     更新（UPDATE）
DELETE:  删除（DELETE）

PATCH 部分更新

URL宾语

宾语顾名思义，是一个名词，URL作为API的宾语是作用HTTP的对象，普遍以复数形式存在.

以下为错误示例：

/getAllCars
/createNewCar
/deleteAllRedCars

正确示例：

/aticles
/users
/cars

煮个栗子

 GET    /zoos：列出所有动物园
 POST   /zoos：新建一个动物园
 GET    /zoos/ID：获取某个指定动物园的信息
 PUT    /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
 PATCH  /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
 DELETE /zoos/ID：删除某个动物园
 GET    /zoos/ID/animals：列出某个指定动物园的所有动物
 DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物

过滤（filter）

通常在数据库中存储着许多数据，我们不可能将所有数据返回给用户，而是选择性的将一些数据返回给用户，而API就应该提供一些参数，过滤返回的结果。

下面是一些常见的参数。

?limit=10：指定返回记录的数量
?offset=10：指定返回记录的开始位置。
?page=2&per_page=100：指定第几页，以及每页的记录数。
?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序。
?animal_type_id=1：指定筛选条件

参数的设计允许存在冗余，即允许API路径和URL参数偶尔有重复。比如，GET /zoo/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的。

不符合 CRUD 情况的 RESTful API

在实际资源操作中，总会有一些不符合 CRUD 的情况，一般有几种处理方法。

1、使用 POST，为需要的动作增加一个 endpoint，使用 POST 来执行动作，比如: POST /resend 重新发送邮件。
2、增加控制参数，添加动作相关的参数，通过修改参数来控制动作。比如一个博客网站，会有把写好的文章“发布”的功能，可以用上面的 POST /articles/{:id}/publish 方法，也可以在文章中增加 published:boolean 字段，发布的时候就是更新该字段 PUT /articles/{:id}?published=true
3、把动作转换成资源，把动作转换成可以执行 CRUD 操作的资源， github 就是用了这种方法。比如“喜欢”一个 gist，就增加一个 /gists/:id/star 子资源，然后对其进行操作：“喜欢”使用PUT /gists/:id/star，“取消喜欢”使用 DELETE /gists/:id/star。另外一个例子是 Fork，这也是一个动作，但是在 gist 下面增加 forks资源，就能把动作变成 CRUD 兼容的：POST /gists/:id/forks 可以执行用户 fork 的动作。

动词覆盖，应对服务器不完全支持 HTTP 的情况

有些客户端只能使用GET和POST这两种方法。服务器必须接受POST模拟其他三个方法（PUT、PATCH、DELETE）。这时，客户端发出的 HTTP 请求，要加上X-HTTP-Method-Override属性，告诉服务器应该使用哪一个动词，覆盖POST方法。

API响应

状态码

2xx 状态码

200状态码也称成功状态码，但是对于不同的方法又有不同的状态码

GET --> 200 OK
POST--> 201 Created（表示生成新的资源）
PUT --> 200 OK
PATCH --> 200 OK
DELETE --> 204 No Content（表示该资源已不存在）

3xx 状态码

在Restful API中用不上，永久重定向（301）、暂时重定向（302、307）可由应用级别返回，浏览器直接跳转。主要使用303 see other，以表示参考另一个URL，它与302和307的含义一样，也是”暂时重定向”，区别在于302和307用于GET请求，而303用于POST、PUT和DELETE请求。收到303以后，浏览器不会自动跳转，而会让用户自己决定下一步怎么办。

4xx 状态码

4xx 状态码表示客户端错误，主要有下面几种：

400 --> Bad Request：服务器不理解客户端的请求，未做任何处理。
401 --> Unauthorized：用户未提供身份验证凭据，或者没有通过身份验证。
403 --> Forbidden：用户通过了身份验证，但是不具有访问资源所需的权限。
404 --> Not Found：所请求的资源不存在，或不可用。
405 --> Method Not Allowed：用户已经通过身份验证，但是所用的 HTTP 方法不在他的权限之内。
410 --> Gone：所请求的资源已从这个地址转移，不再可用。
415 --> Unsupported Media Type：客户端要求的返回格式不支持。比如，客户端要求返回XML格式，API只能返回JSON格式。
422 --> Unprocessable Entity ：客户端上传的附件无法处理，导致请求失败。
429 --> Too Many Requests：客户端的请求次数超过限额。

5xx 状态码

5xx状态码表示服务端错误。一般来说，API不会向用户透露服务器的详细信息，所以只要两个状态码就够了。

500 --> Internal Server Error：客户端请求有效，服务器处理时发生了意外。
503 --> Service Unavailable：服务器无法处理请求，一般用于网站维护状态。

返回数据

以下事项均为注意事项，不要问为什么，因为站长在学之前全都犯过。

不要返回纯本文

API 返回的数据格式，不应该是纯文本，而应该是一个 JSON 对象，因为这样才能返回标准的结构化数据。所以，服务器回应的 HTTP 头的Content-Type属性要设为application/json。客户端请求时，也要明确告诉服务器，可以接受 JSON 格式，即请求的 HTTP 头的ACCEPT属性也要设成application/json。

不要包装数据

response 的 body直接就是数据，不要做多余的包装。错误实例：

{
  "success": true,
  "data": {
    "id": 1,
    "name": "周伯通"
  }
}

针对不同操作，服务器向用户返回的结果应该符合以下规范。

 GET    /collection：返回资源对象的列表（数组）
 GET    /collection/resource：返回单个资源对象
 POST   /collection：返回新生成的资源对象
 PUT    /collection/resource：返回完整的资源对象
 PATCH  /collection/resource：返回完整的资源对象
 DELETE /collection/resource：返回一个空文档

发生错误时，不要返回 200 状态码

有一种不恰当的做法是，即使发生错误，也返回200状态码，把错误信息放在数据体里面，就像下面这样。

{
  "status": "failure",
  "data": {
    "error": "Expected at least two items in list."
  }
}

正确的做法是，状态码反映发生的错误，具体的错误信息放在数据体里面返回。下面是一个例子。

HTTP/1.1 400 Bad Request
Content-Type: application/json
{
  "error": "Invalid payoad.",
  "detail": {
    "surname": "This field is required."
  }
}

Vue学习笔记（二）

Sat, 15 Mar 2025 11:06:32 GMT

组件基础

组件定义

Vue组件定义在一个.vue的文件中，被称为单文件组件SFC :

<script setup>
  import { ref } from 'vue'

  const count = ref(0)
</script>

<template>
  <button @click="count++">You clicked me {{ count }} times.</button>
</template>

组件使用

若要使用一个子组件，需要在父组件中导入。假设我们把计数器组件放在了一个叫做 ButtonCounter.vue 的文件中，这个组件将会以默认导出的形式被暴露给外部：

<script setup>
  import ButtonCounter from './ButtonCounter.vue'
</script>

<template>
  <h1>Here is a child component!</h1>
  <ButtonCounter />
</template>

若是通过 <script setup> 导入的组件，可以在<template> </template> 中直接使用。同时，一个组件可在同一个模板中引用多次：

<template>
  <ButtonCounter />
  <ButtonCounter />
  <ButtonCounter />
</template>

对于以上的示例，每个ButtonCounter 组件在进行点击后不会影响其余的组件，因为每个组件都是维护自己的状态，每当我使用一个组件就新创建一个实例。

传递 props

如果我们正在构建一个博客，我们可能需要一个表示博客文章的组件。我们希望所有的博客文章分享相同的视觉布局，但有不同的内容。要实现这样的效果自然必须向组件中传递数据，例如每篇文章标题和内容，这就会使用到 props。

Props 是一种特别的 attributes，你可以在组件上声明注册。要传递给博客文章组件一个标题，我们必须在组件的 props 列表上声明它。这里要用到 defineProps 宏：

<!-- BlogPost.vue -->
<script setup>
  defineProps(['title'])
</script>

<template>
  <h4>{{ title }}</h4>
</template>

defineProps是一个仅<script setup>中可用的编译宏命令，并不需要显式地导入。声明的 props 会自动暴露给模板。defineProps会返回一个对象，其中包含了可以传递给组件的所有 props：

const props = defineProps(['title'])
console.log(props.title)

一个组件可以有任意多的 props，默认情况下，所有 prop 都接受任意类型的值。当一个 prop 被注册后，可以像这样以自定义 attribute 的形式传递数据给它：

<BlogPost title="My journey with Vue" />
<BlogPost title="Blogging with Vue" />
<BlogPost title="Why Vue is so fun" />

在实际应用中，我们可能在父组件中会有如下的一个博客文章数组：

const posts = ref([
  { id: 1, title: 'My journey with Vue' },
  { id: 2, title: 'Blogging with Vue' },
  { id: 3, title: 'Why Vue is so fun' }
])

这种情况下，我们可以使用v-for来渲染它们：

<BlogPost v-for="post in posts" :key="post.id" :title="post.title" />

留意我们是如何使用v-bind语法(:title="post.title") 来传递动态 prop 值的。当事先不知道要渲染的确切内容时，这一点特别有用。

监听事件

Vue学习笔记（一）

Mon, 10 Mar 2025 09:47:53 GMT

部分示例来源于vuejs中文官网

Vue3对Vue2向下兼容，但部分不兼容

语法

文本插值：

在HTML中插入文本

HTML插值：

上述操作只能插入纯文本，可以使用v-html插入html文本

<p>Using v-html directive: <span v-html="rawHtml"></span></p>

Attribute 绑定

对使用的元素属性进行绑定想响应式绑定一个Attribute,但又不能使用{{ }}时,可使用v-bind指令：

<div v-bind:id="num"></div>

v-bind指令指示 Vue 将元素的idattribute 与组件的num属性保持一致。如果绑定的值是null或者undefined，那么该 attribute 将会从渲染的元素上移除。简写：

<div :id="num"></div>

示例：

//点击方块后颜色切换，其中click和ref会在下面会讲到
<template>
  <div style="height: 100px; width: 100px;" @click="switchColor" :class="str"></div>
</template>
<script setup>
  import { ref } from 'vue'

  let str = ref('su')

  function switchColor() {
    str.value = 's'
  }
</script>
<style scoped>
  .su {
    background-color: red;
  }

  .s {
    background-color: green;
  }
</style>

也可设为bool型数据

<button :disabled="isButtonDisabled">Button</button>

当isButtonDisabled为真值或一个空字符串 (即
<button disabled="">) 时，元素会包含这个disabled attribute。而当其为其他假值时 attribute 将被忽略。

动态绑定多个值

如果你有像这样的一个包含多个 attribute 的 JavaScript 对象：

const objectOfAttrs = {
  id: 'container',
  class: 'wrapper',
  style: 'background-color:green'
}

通过不带参数的v-bind，你可以将它们绑定到单个元素上：

<div v-bind="objectOfAttrs"></div>

使用 JavaScript 表达式

至此，我们仅在模板中绑定了一些简单的属性名。但是 Vue 实际上在所有的数据绑定中都支持完整的 JavaScript 表达式：

{{ number + 1 }} {{ ok ? 'YES' : 'NO' }} {{ message.split('').reverse().join('') }}
<div :id="`list-${id}`"></div>

这些表达式都会被作为 JavaScript ，以当前组件实例为作用域解析执行。在 Vue 模板内，JavaScript 表达式可以被使用在如下场景上：

在文本插值中 (双大括号)
在任何 Vue 指令 (以v-开头的特殊 attribute) attribute 的值中

仅支持表达式

每个绑定仅支持单一表达式，也就是一段能够被求值的 JavaScript 代码。一个简单的判断方法是是否可以合法地写在return后面。

因此，下面的例子都是无效的：

<!-- 这是一个语句，而非表达式 -->
{
    {
        var a = 1
    }
}

<!-- 条件控制也不支持，请使用三元表达式 -->
{
    {
        if (ok) {
            return message
        }
    }
}

调用函数

可以在绑定的表达式中使用一个组件暴露的方法：

<time :title="toTitleDate(date)" :datetime="date"> {{ formatDate(date) }} </time>

Tip: 绑定在表达式中的方法在组件每次更新时都会被重新调用，因此不应该产生任何副作用，比如改变数据或触发异步操作。

受限的全局访问

模板中的表达式将被沙盒化，仅能够访问到有限的全局对象列表。该列表中会暴露常用的内置全局对象，比如Math和Date。没有显式包含在列表中的全局对象将不能在模板内表达式中访问，例如用户附加在window上的属性。然而，你也可以自行在app.config.globalProperties上显式地添加它们，供所有的 Vue 表达式使用。

响应式基础

ref()

组合式API中,使用ref()函数声明响应式状态

import { ref } from 'vue'

const num = ref(100)

ref()接收参数，并将其包裹在一个带有.value属性的 ref 对象中返回所以vue中的js需要使用组合式setup()，并且在使用时需要添加上.value

示例：

<template>
  <button @click="increment">{{ count }}</button>
</template>

<script setup>
  import { ref } from 'vue'

  const count = ref(0)

  function increment() {
    count.value++
  }
</script>

vue2中使用set()实现响应式，而在vue3中使用ref()，并且vue3不兼容set()函数

深层响应性

Ref 可以持有任何类型的值，包括深层嵌套的对象、数组或者 JavaScript 内置的数据结构，比如Map。

Ref 会使它的值具有深层响应性。这意味着即使改变嵌套对象或数组时，变化也会被检测到：

import { ref } from 'vue'

const obj = ref({
  nested: { count: 0 },
  arr: ['foo', 'bar']
})

function mutateDeeply() {
  // 以下都会按照期望工作
  obj.value.nested.count++
  obj.value.arr.push('baz')
}

reactive()

reactive()是响应式的另一种API，reactive()可使对象本身具有响应性

import { reactive } from 'vue'

const state = reactive({ count: 0 })

在template中以下方式使用：

<template>
  <button @click="state.cnt ++">{{ state.cnt }}</button>
</template>

计算属性

基础示例

<template>
  <span>{{ author.books.length > 0 ? "YES" : "NO" }}</span>
</template>

<script setup>
  import { reactive } from 'vue'

  const author = reactive({
    name: 'John Doe',
    books: ['Vue 2 - Advanced Guide', 'Vue 3 - Basic Guide', 'Vue 4 - The Mystery']
  })
</script>

在上述示例中，可以发现计算是依靠author.books的大小确定的，如果我在模板中多次使用这样的判断，是否显得过于臃肿。
对于这样的判断可以引入computed().

computed()

<script setup>
  import { computed, reactive } from 'vue'

  const author = reactive({
    name: 'John Doe',
    books: ['Vue 2 - Advanced Guide', 'Vue 3 - Basic Guide', 'Vue 4 - The Mystery']
  })

  // 一个计算属性 ref
  const publishedBooksMessage = computed(() => {
    return author.books.length > 0 ? 'Yes' : 'No'
  })
</script>

<template>
  <p>Has published books:</p>
  <span>{{ publishedBooksMessage }}</span>
</template>

我们在这里定义了一个计算属性publishedBooksMessage。computed()
方法期望接收一个getter 函数
，返回值为一个计算属性 ref。和其他一般的 ref 类似，你可以通过publishedBooksMessage.value访问计算结果。计算属性 ref
也会在模板中自动解包，因此在模板表达式中引用时无需添加.value。

Vue 的计算属性会自动追踪响应式依赖。它会检测到publishedBooksMessage依赖于author.books，所以当author.books改变时，任何依赖于
publishedBooksMessage的绑定都会同时更新。

可写计算属性

计算属性默认是只读的。当你尝试修改一个计算属性时，你会收到一个运行时警告。只在某些特殊场景中你可能才需要用到“可写”的属性，你可以通过同时提供
getter 和 setter 来创建：

<template>
    {{fullName}}
</template>
<script setup>
    import {ref, computed} from 'vue'

    const firstName = ref('John')
    const lastName = ref('Doe')

    const fullName = computed({
    // getter
    get() {
    return firstName.value + ' ' + lastName.value
},
    // setter
    set(newValue) {
    // 注意：我们这里使用的是解构赋值语法
    [firstName.value, lastName.value] = newValue.split(' ')
}})

    console.log(fullName.value, firstName.value, lastName.value);

    fullName.value = "Jack Doe";

    console.log(fullName.value, firstName.value, lastName.value);
</script>

在上述示例中，当运行fullName.value = "Jack Doe";时，firstName和lastName也会随之更新。

类与样式绑定

绑定HTML class

绑定对象

绑定对象一般使用v-bind，比如绑定class一般写为v-bind:class 简写为:class,对其传递对象可动态切换class：

<div :class="{ active: isActive }"></div>

其中class的active是否存在由isActive的真值来确定。
对象中可通过多个字段class对象
例如：

<template>
  <div class="static" :class="{ active: isActive, 'text-danger': hasError }">123</div>
</template>
<script setup>
  import { ref } from 'vue'

  const isActive = ref(true)
  const hasError = ref(false)
</script>

<style scoped>
  .text-danger {
    color: red;
  }
</style>

在上述示例中，字段active, hasError 的真值影响在class类中是否存在对应的类名。当hasError为真时，由于css中的text-danger
样式，会将字体123改变为红色。
上述示例渲染后的效果如下：

<div class="static active">123</div>

通过以上，我们可以对：class传入一个对象

<template>
  <div class="static" :class="obj">123</div>
</template>
<script setup>
  import { reactive } from 'vue'

  const obj = reactive({
    active: true,
    'text-danger': false
  })
</script>

<style scoped>
  .text-danger {
    color: red;
  }
</style>

传入对象方法渲染后的效果同上，个人较为喜欢多个字段操作

我们也可以绑定一个返回对象的[[#计算属性]]。这是一个常见且很有用的技巧：

const isActive = ref(true)
const error = ref(null)

const obj = computed(() => ({
  active: isActive.value && !error.value,
  'text-danger': error.value && error.value.type === 'fatal'
}))

<div :class="classObject"></div>

绑定数组

我们可以给:class绑定一个数组来渲染多个 CSS class：

const activeClass = ref('active')
const errorClass = ref('text-danger')

<div :class="[activeClass, errorClass]"></div>

渲染的结果是：

<div class="active text-danger"></div>

如果你也想在数组中有条件地渲染某个 class，你可以使用三元表达式：

<div :class="[isActive ? activeClass : '', errorClass]"></div>

errorClass会一直存在，但activeClass只会在isActive为真时才存在。

然而，这可能在有多个依赖条件的 class 时会有些冗长。因此也可以在数组中嵌套对象：

<div :class="[{ [activeClass]: isActive }, errorClass]"></div>

在组件上使用

本节假设你已经有Vue 组件的知识基础。如果没有，你也可以暂时跳过，以后再阅读。

对于只有一个根元素的组件，当你使用了classattribute 时，这些 class 会被添加到根元素上并与该元素上已有的 class 合并。

举例来说，如果你声明了一个组件名叫MyComponent，模板如下：

<!-- 子组件模板 -->
<p class="foo bar">Hi!</p>

在使用时添加一些 class：

<!-- 在使用组件时 -->
<MyComponent class="baz boo" />

渲染出的 HTML 为：

<p class="foo bar baz boo">Hi!</p>

Class 的绑定也是同样的：

<MyComponent :class="{ active: isActive }" />

当isActive为真时，被渲染的 HTML 会是：

<p class="foo bar active">Hi!</p>

如果你的组件有多个根元素，你将需要指定哪个根元素来接收这个 class。你可以通过组件的$attrs属性来指定接收的元素：

<!-- MyComponent 模板使用 $attrs 时 -->
<p :class="$attrs.class">Hi!</p>
<span>This is a child component</span>

<MyComponent class="baz" />

这将被渲染为：

<p class="baz">Hi!</p>
<span>This is a child component</span>

你可以在透传 Attribute一章中了解更多组件的 attribute 继承的细节。

绑定内联样式

绑定对象

:style支持绑定 JavaScript 对象值，对应的是HTML 元素的style属性：

const activeColor = ref('red')
const fontSize = ref(30)

<div :style="{ color: activeColor, fontSize: fontSize + 'px' }"></div>

尽管推荐使用 camelCase，但:style也支持 kebab-cased 形式的 CSS 属性 key (对应其 CSS 中的实际名称)，例如：

<div :style="{ 'font-size': fontSize + 'px' }"></div>

直接绑定一个样式对象通常是一个好主意，这样可以使模板更加简洁：

const styleObject = reactive({
  color: 'red',
  fontSize: '30px'
})

<div :style="styleObject"></div>

同样的，如果样式对象需要更复杂的逻辑，也可以使用返回样式对象的计算属性。

绑定数组

我们还可以给:style绑定一个包含多个样式对象的数组。这些对象会被合并后渲染到同一元素上：

<div :style="[baseStyles, overridingStyles]"></div>

自动前缀

当你在:style中使用了需要浏览器特殊前缀的 CSS
属性时，Vue 会自动为他们加上相应的前缀。Vue 是在运行时检查该属性是否支持在当前浏览器中使用。如果浏览器不支持某个属性，那么将尝试加上各个浏览器特殊前缀，以找到哪一个是被支持的。

样式多值

你可以对一个样式属性提供多个 (不同前缀的) 值，举例来说：

<div :style="{ display: ['-webkit-box', '-ms-flexbox', 'flex'] }"></div>

数组仅会渲染浏览器支持的最后一个值。在这个示例中，在支持不需要特别前缀的浏览器中都会渲染为display: flex。

LaTex

Thu, 13 Feb 2025 00:00:00 GMT

LaTex 下书写数学公式、表达式以及各种数学符号

什么是 LaTex
如何使用 Latex 写数学符号
数学符号
Functions
希腊字母
向量
集合
逻辑
微积分
三角函数
其他 _ cases _ 公式换行、对齐 _ substack _ matrix
最后
Ref:

什么是 LaTex

Latex 是一个用于书写以及排版的计算机语言。它在写数学符号和公式方面尤其方便。

如何使用 Latex 写数学符号

在 Latex 中有三种方法来写数学符号：

行内(inline)形式（符号以及公式夹杂在文本的中间，例如这样 $E=mc^2$ ）
独立的一行(equation)

\begin{equation} x=\frac{-b\pm\sqrt{b^2-4ac}}{2a} \end{equation}
full-sized 行内表达式（通过 displaystyle）为了得到这种形式的表达式需要使用 \displaystyle。例如： I want this $\displaystyle \sum_{n=1}^{\infty}\frac{1}{n}$ ,not this $\sum_{n=1}^{\infty} \frac{1}{n}, I want this $\displaystyle \sum_{n=1}^{\infty}\frac{1}{n}$ ,not this $\sum_{n=1}^{\infty} \frac{1}{n}$ 。

数学符号

下面是比较常用的一些：

| 描述 | 命令 | ------------------------ | ----------------- | addition | + | subtraction | - | $-$ | plus or minus | \pm | multiplication(times) | \times | multiplication(dot) | \cdot | division symbol | \div | division(slash) | / | simple text | \text{text} | infinity | \infty | dots | 1,2,3,\ldots | dots | 1+2+3+\cdots | fraction | \frac{a}{b} | nth root | \sqrt[n]{x} | square root | \sqrt{x} | exponentiation | a^b | subscript | a_b | natural log | \ln(x) | logarithms | \log_{a}b | exp | \exp | deg | \deg(f) | arcmin | ^\prime | arcsec | ^{\prime\prime} | circle plus | \oplus | circle times | \otimes | equal | = | $=$ | not equal | \ne | less than | < | less than or equal to | \le | greater than or equal to | \ge | approximately equal to | \approx | 输出 | | ----------------------- | | $+$ | | | $\pm$ | | $\times$ | | $cdot$ | | $\div$ | | $/$ | | $\text{text}$ | | $\infty$ | | $1,2,3,\ldots$ | | $1+2+3+\cdots$ | | $\frac{a}{b}$ | | $\sqrt[n]{x}$ | | $\sqrt{x}$ | | $a^b$ | | $a_b$ | | $\ln(x)$ | | $\log_{a}b$ | | $\exp$ | | $deg(f)$ | | $^\prime$ | | $^{\prime\prime}$ | | $\oplus$ | | $\otimes$ | | | $\ne$ | | $<$ | | $\le$ | | $\ge$ | | $\approx$ |

Functions

| 描述 | 命令 | 输出 | | ----------- | ------- | ------------ | | maps to | \to | $\to$ | | composition | \circ | $\circ$ |

希腊字母

| 命令 | 输出 | 命令 | 输出 | | ------------- | ------------------ | ---------- | --------------- | | \alpha | $\alpha$ | \tau | $\tau$ | | \beta | $\beta$ | \theta | $\theta$ | | \chi | $\chi$ | \upsilon | $\upsilon$ | | \delta | $\delta$ | \xi | $\xi$ | | \epsilon | $\epsilon$ | \zeta | $\zeta$ | | \varepsilon | $\varepsilon$ | \Delta | $\Delta$ | | \eta | $\eta$ | \Gamma | $\Gamma$ | | \gamma | $\gamma$ | Lambda | $\Lambda$ | | \iota | $\iota$ | \Omega | $\Omega$ | | \kappa | $\kappa$ | \Phi | $\Phi$ | | lambda | $\lambda$ | \Pi | $\Pi$ | | \mu | $\mu$ | \Psi | $\Psi$ | | \nu | $\nu$ | Sigma | $\Sigma$ | | \omega | $\omega$ | \Theta | $Theta$ | | \phi | $\phi$ | \Upsilon | $\Upsilon$ | | \varphi | $\varphi$ | \Xi | $\Xi$ | | \pi | $\pi$ | \aleph | $\aleph$ | | \psi | $\psi$ | \beth | $\beth$ | | \rho | $\rho$ | \daleth | $\daleth$ | | \sigma | $\sigma$ | \gimel | $\gimel$ |

向量

| 描述 | 命令 | 输出 | | ------ | ------------ | ----------------- | | vector | \vec{v} | $\vec{v}$ | | vector | \mathbf{v} | $\mathbf{v}$ |

集合

| 描述 | 命令 | 输出 | | ------------------- | ----------------------- | ----------------------------- | | set brackets | \{1,2,3\} | $\{1,2,3\}$ | | element of | \in | $\in$ | | subset of | \subset | $\subset$ | | subset of | \subseteq | $\subseteq$ | | contains | \supset | $\supset$ | | contains | \supseteq | $\supseteq$ | | union | \cup | $\cup$ | | intersection | \cap | $\cap$ | | big union | \bigcup_{n=1}^{10}A_n | $\bigcup_{n=1}^{10}A_n$ | | | \bigcap_{n=1}^{10}A_n | $\bigcap_{n=1}^{10}A_n$ | | | \emptyset | $\emptyset$ | | | \mathcal{P} | $\mathcal{P}$ | | | \min | $\min$ | | | \max | $\max$ | | | \sup | $\sup$ | | | \inf | $\inf$ | | | \limsup | $\limsup$ | | | \liminf | $\liminf$ | | | \overline{A} | $\overline{A}$ | | Set of real numbers | \mathbb{R} | $\mathbb{R}$ | | | | |

逻辑

| 描述 | 命令 | 输出 | | -------------- | ----------------- | ---------------------- | | not | \sim | $\sim$ | | and | \land | $\land$ | | or | \lor | $\lor$ | | if..then | \to | $\to$ | | if and only if | \leftrightarrow | $\leftrightarrow$ | | logical eq | \equiv | $\equiv$ | | therefore | ∴ | $\therefore$ | | there exists | \exists | $\exists$ | | for all | \forall | $\forall$ | | implies | \Rightarrow | $\Rightarrow$ | | equivalent | \Leftrightarrow | $\Leftrightarrow$ |

微积分

| 描述 | 命令 | 输出 | | ------------------ | -------------------------------- | --------------------------------------- | | derivative | \frac{df}{dx} | $\frac{df}{dx}$ | | derivative | f' | $f'$ | | partial derivative | \frac{\partial f} {\partial x} | $\frac{\partial f} {\partial x}$ | | limits | \lim_{x\to \infty} | $\lim_{x\to \infty}$ | | sum | \sum_{n=1}^{\infty}a_n | $\sum_{n=1}^{\infty}a_n$ | | product | \prod_{n=1}^{\infty}a_n | $\prod_{n=1}^{\infty}a_n$ | | integral | \int | $\int$ | | | \iint | $\iint$ | | | \iiint | $\iiint$ |

三角函数

| 描述 | 命令 | 输出 | | ---- | --------------- | -------------------- | | | \angle ABC | $\angle ABC$ | | | 90^{\circ} | $90^{\circ}$ | | | \triangle ABC | $\triangle ABC$ | | | \overline{AB} | $\overline{AB}$ | | | \sin | $\sin$ | | | \cos | $\cos$ | | | \tan | $\tan$ | | | \cot | $\cot$ | | | \sec | $\sec$ | | | \csc | $\csc$ | | | \arcsin | $\arcsin$ | | | \arccos | $\arccos$ | | | \arctan | $\arctan$ |

其他

| 描述 | 命令 | 输出 | | ---------- | ----------------------------------- | ------------------------------------------- | | underbrace | \underbrace{}_{} | $\underbrace{}_i$ | | boxed | \boxed | $\boxed{\frac {a} {b}}$ | | hat | \hat{} | $\hat{\theta}$ | | | \widehat{d e f} | $\widehat{d e f}$ | | overbrace | \overbrace{}^{} | $\overbrace{ 1+2+\cdots+100 }^{5050}$ | | | \binom{n}{k} | $\binom{n}{k}$ | | | op\stackrel{a}{\longrightarrow}op | $op\stackrel{a}{\longrightarrow}op$ |

\binom{n}{k} \end{equation}

cases

写法：

\begin{equation} F= \begin{cases} a & {b=0}\\ c & {d=1} \end{cases} \end{equation}

效果：

\begin{equation} F= \begin{cases} a & {b=0}\\ c & {d=1} \end{cases} \end{equation}

或者这种写法：

f(n) = \begin{cases} n/2, & \mbox{if }n\mbox{ is even} \\ 3n+1, & \mbox{if }n\mbox{ is odd} \end{cases}

公式换行、对齐

写法：

\begin{align} F &= a + b \\&=c+d \\&=e+f \end{align}

效果：

\begin{align} F &= a + b \\&=c+d \\&=e+f \end{align}

关键是 align, & 用于对齐， \\用于换行

substack

\begin{equation} \sum_{\substack{-m \le j \le +m \\ j \ne 0}} \end{equation}

使限制条件处于并列的两行：

\begin{equation} \sum_{\substack{-m \le j \le +m \\ j \ne 0}} \end{equation}

matrix

\begin{vmatrix} x & y \\ z & v \end{vmatrix}

\begin{equation} \begin{vmatrix} x & y \\ z & v \end{vmatrix} \end{equation}

\begin{Vmatrix} x & y \\ z & v \end{Vmatrix}

\begin{equation} \begin{Vmatrix} x & y \\ z & v \end{Vmatrix} \end{equation}

\begin{pmatrix} x & y \\ z & v \end{pmatrix}

\begin{equation} \begin{pmatrix} x & y \\ z & v \end{pmatrix} \end{equation}

最后

如果是写一些笔记或者论文中有大量数学符号，我推荐使用 Org mode 来写，真的非常非常方便，如果你体验过一次就会知道。对很多人来说，这个其实门槛有点高了，因为你必须要对 Emacs 有所熟悉才行。 Org mode 下原生支持的符号可参考：Symbols in Org-mode 。

Ref:

Codeforces Round 1002 (Div.2)

Fri, 07 Feb 2025 14:08:54 GMT

A. Milya and Two Arrays

A. Milya and Two Arrays

题目描述

给你两个长度为n的数组a和b，a,b中的每个元素都至少出现两次。你可以重新排列a，最后要使得ai+bi的不同种类大于等于3。

解题思路

统计a和b的种类数cnt1,cnt2，因为长度为n且每个种类的数至少出现两次，所以a中每个数贡献的种类数就是出现次数，出现次数，min( 出现次数，cnt2)，只要cnt1∗cnt2>=3就行。赛时没想的很清楚写的cnt1+cnt2>=4，其实一样。

参考代码

void solve() {
  int n;
  std::cin >> n;
  std::set<int> a, b;
  for (int i = 0; i < n; ++ i) {
  	int x;
  	std::cin >> x;
  	a.insert(x);
  }

  for (int i = 0; i < n; ++ i) {
  	int x;
  	std::cin >> x;
  	b.insert(x);
  }

  if (a.size() + b.size() >= 4) {
  	std::cout << "YES" << endl;
  } else {
  	std::cout << "NO" << endl;
  }
}

B. Cost of the Array time limit per test1 second

B. Cost of the Array time limit per test1 second

题目描述

给你一个长度为n数组a和一个偶数k。你要把a分成k份。然后把所有偶数份按顺序拼到一起，得到b，求可以得到的bi!=i的最小的i。

解题思路

我们让所有的k−1份都只占一个位置，第二份占多个位置，看能不能不让1开头，如果有我们可以把前面的1都给第一份，那么答案就是1。否则就全部都是1，那么全部给第二个份，那么答案就是2。
注意要特判n==k的情况

参考代码

void solve() {
  int n, k;
  std::cin >> n >> k;
  std::vector<int> a(n);
  for (int i = 0; i < n; ++ i) {
  	std::cin >> a[i];
  }

  if (n == k) {
  	for (int i = 1, j = 1; i < n; i += 2, j ++ ) {
  		if (a[i] != j) {
  			std::cout << j << endl;
  			return;
  		}
  	}

  	std::cout << k / 2 + 1 << endl;
  	return;
  } else {
  	for (int i = 1; i < n - (k - 2); ++ i) {
  		if (a[i] != 1) {
  			std::cout << 1 << endl;
  			return;
  		}
  	}

  	std::cout << 2 << endl;
  }
}

C. Customer Service

C. Customer Service

题目描述

给你n个长度为n的数组，你要给每一个数组截断一次，且所有数组截断的位置凑起来正好是一个排列。然后每个数组的值就是截断的后一部分的和。你要让所有数组和的mex最大。

解题思路

记录每个数组的后缀和与后缀长度相等的位置，那么保留这一段位置可以得到一个数字。于是我们从小到大枚举mex只要有一个没有被操作过的数组可以贡献这个值，就可以继续操作，否则就是答案。然后考虑每个值由哪个数组贡献，应该让可以贡献的最大值最小的数组来贡献这个值。因为其他数组都可以贡献更大的值，应该留下来。

参考代码

void solve() {
  int n;
  std::cin >> n;
  std::vector a(n, std::vector<int>(n));
  for (int i = 0; i < n; ++ i) {
  	for (int j = 0; j < n; ++ j) {
  		std::cin >> a[i][j];
  	}
  	a[i].push_back(0);
  	std::reverse(a[i].begin(), a[i].end());
  }

  std::vector<std::set<std::pair<int, int> > > s(n + 1);
  std::vector<int> b(n);
  for (int i = 0; i < n; ++ i) {
  	i64 t = 0;
  	for (int j = 0; j <= n; ++ j) {
  		t += a[i][j];
  		if (j == n || t != j) {
  			b[i] = j;
  			break;
  		}
  	}

  	for (int j = 0; j < b[i]; ++ j) {
  		s[j].insert({b[i], i});
  	}
  }

  for (int i = 0; i <= n; ++ i) {
  	if (s[i].empty()) {
  		std::cout << i << endl;
  		return;
  	}

  	auto [_, x] = *s[i].begin();
  	s[i].erase(s[i].begin());
  	for (int j = 0; j < b[x]; ++ j) {
  		s[j].erase({b[x], x});
  	}
  }
}

D. Graph and Graph

D. Graph and Graph

题目描述

给你两个由n个顶点的图，你在图一和图二各有一个起点，你每次要在这两个图上移动，假设从图一移动到了u, 图二移动到了v，移动代价是|u−v|。你要进行无限次操作，求操作的最小代价。

解题思路

显然我们让两个图都到一个相同的点u，使得有一个v在图一和图二上都和u有边。那么可以在这两个点上反复横跳，代价是0。否则代价是正无穷。那么可以考虑最短路，dist[i][j]表示图一在i，图二在j时的最小代价。最后枚举每个i，看有没有一个j使得在两个图上都有边，然后取最小值即可。

参考代码

void solve() {
  int n, s1, s2;
  std::cin >> n >> s1 >> s2;
  -- s1, -- s2;
  std::vector g1(n, std::vector<int>(n));
  std::vector g2(n, std::vector<int>(n));
  std::vector<std::vector<int> > adj1(n);
  std::vector<std::vector<int> > adj2(n);
  int m1, m2;
  std::cin >> m1;
  for (int i = 0; i < m1; ++ i) {
  	int u, v;
  	std::cin >> u >> v;
  	-- u, -- v;
  	g1[u][v] = g1[v][u] = 1;
  	adj1[u].push_back(v);
  	adj1[v].push_back(u);
  }

  std::cin >> m2;
  for (int i = 0; i < m2; ++ i) {
  	int u, v;
  	std::cin >> u >> v;
  	-- u, -- v;
  	g2[u][v] = g2[v][u] = 1;
  	adj2[u].push_back(v);
  	adj2[v].push_back(u);
  }

  const int inf = 1e9;
  std::vector dist(n, std::vector<int>(n, inf));
  std::vector vis(n, std::vector<int>(n));
  using A = std::array<int, 3>;
  std::priority_queue<A, std::vector<A>, std::greater<A> > heap;
  dist[s1][s2] = 0;
  heap.push({0, s1, s2});
  while (heap.size()) {
  	auto [_, x, y] = heap.top(); heap.pop();
  	if (vis[x][y]) {
  		continue;
  	}

  	for (auto & i : adj1[x]) {
  		for (auto & j : adj2[y]) {
  			if (dist[i][j] > dist[x][y] + std::abs(i - j)) {
  				dist[i][j] = dist[x][y] + std::abs(i - j);
  				if (!vis[i][j]) {
  					heap.push({dist[i][j], i, j});
  				}
  			}
  		}
  	}
  }

  int ans = inf;
  for (int i = 0; i < n; ++ i) {
  	for (int j = 0; j < n; ++ j) {
  	  if (g1[i][j] && g2[i][j]) {
  		  ans = std::min(ans, dist[i][i]);
  		}
  	}
  }

  if (ans == inf) {
  	ans = -1;
  }
  std::cout << ans << endl;
}

将Github pages打包为移动端应用

Sat, 18 Jan 2025 01:28:14 GMT

配置环境

首先我们得先配置好环境我这里用的是IDEA,也可以用android studio

首先在IDEA中安装一个叫Android的插件下载好后我们需要创建项目框选的位置一定要修改(language有误，应该选择kotlin) 可能会提示下载SDK，直接下载就行了创建好后，我们需要修改gradle镜像源将框选的地址换为

https://mirrors.cloud.tencent.com/gradle/gradle-8.2-all.zip

修改后，重新加载gradle项目即可

项目搭建

首先我们找到文件app\src\main\java\com\example\myapplication\MainActivity 若没有修改项目名称，那路径就和我一样的将以下代码复制到上面的文件中,项目名称不同下述代码的第一行不用复制，粘贴的时候要保留原有的第一行

package com.example.myapplication

import android.annotation.SuppressLint
import android.app.AlertDialog
import android.os.Bundle
import android.util.Log
import android.view.View
import android.webkit.WebResourceRequest
import android.webkit.WebSettings
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.activity.ComponentActivity
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit


class MainActivity : ComponentActivity() {

    private lateinit var webView: WebView
    private lateinit var swipeRefreshLayout: SwipeRefreshLayout
    private val executor = ThreadPoolExecutor(
        2, // 核心线程数
        4, // 最大线程数
        30L, TimeUnit.SECONDS, // 空闲线程存活时间
        LinkedBlockingQueue(20) // 任务队列容量
    )

    @SuppressLint("SetJavaScriptEnabled")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        showWelcomeDialog()

        // 初始化 SwipeRefreshLayout 和 WebView
        swipeRefreshLayout = findViewById(R.id.swipeRefreshLayout)
        webView = findViewById(R.id.webview)

        // 配置 SwipeRefreshLayout
        swipeRefreshLayout.setOnRefreshListener {
            webView.reload() // 刷新网页
        }

        // 配置 WebView
        val webSettings = webView.settings
        webSettings.javaScriptEnabled = true
        webSettings.domStorageEnabled = true
        webSettings.databaseEnabled = true
        webSettings.setSupportMultipleWindows(true)
        webSettings.cacheMode = WebSettings.LOAD_DEFAULT
        webView.setLayerType(View.LAYER_TYPE_HARDWARE, null) // 启用硬件加速

        // 设置 WebViewClient
        webView.webViewClient = object : WebViewClient() {
            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
                val url = request?.url.toString()
                view?.loadUrl(url)
                return true
            }

            override fun onPageFinished(view: WebView?, url: String?) {
                super.onPageFinished(view, url)
                swipeRefreshLayout.isRefreshing = false // 停止刷新动画
            }
        }

        // 加载你的博客网址
        webView.loadUrl("https://anzhiyublog.lazy-boy-acmer.cn")
    }

    @Deprecated("Deprecated in Java")
    override fun onBackPressed() {
        if (::webView.isInitialized && webView.canGoBack()) {
            Log.d("WebView", "Can go back")
            webView.goBack()
        } else {
            Log.d("WebView", "Not going back")
            super.onBackPressed()
        }
    }

    // 显示欢迎提示框
    private fun showWelcomeDialog() {
        val builder = AlertDialog.Builder(this)
        builder.setTitle("\uD83E\uDD74提示")
        builder.setMessage("返回键已修复为可返回之前页面\n现无法跳转外部页面")

        builder.setPositiveButton("确定") { dialog, _ ->
            dialog.dismiss()
        }

        val dialog = builder.create()
        dialog.show()
    }

    // 任务入队
    fun enqueueTriggerTask(task: Runnable): Boolean {
        return try {
            executor.execute(task)
            true
        } catch (e: RejectedExecutionException) {
            Log.e("TaskManager", "Failed to enqueue task", e)
            false
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        executor.shutdown()
    }
}

打开文件 app\src\main\res\layout\activity_main.xml 粘贴以下代码

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="match_parent"
                android:layout_height="match_parent">

    <androidx.swiperefreshlayout.widget.SwipeRefreshLayout
            android:id="@+id/swipeRefreshLayout"
            android:layout_width="match_parent"
            android:layout_height="match_parent">

        <WebView
                android:id="@+id/webview"
                android:layout_width="match_parent"
                android:layout_height="match_parent"/>
    </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
</RelativeLayout>

生成apk

点击菜单栏的 Build -> Build Apk(s) 生成的安装包会在项目根目录下的app\build\outputs\apk\debug里面至于如何修改Apk的名称和图标，大家可以自行百度或AI

npm作为图片存储

Wed, 08 Jan 2025 23:19:34 GMT

创建文件夹

mkdir demo

初始化

npm init -y

打开编译器创建文件`index.js`并填入以下信息

function main() {
  console.log('Hello, world')
}
main()
export default main
export function Hello(name) {
  console.log('${ name }}')
}

打开package.json文件

现在我们来熟悉下这个文件。

| 字段 | 备注 | | -------------- | --------------------------------------------- | | name | npm包的名称，也就是publish后的名称 | | version | 每次publish的时候记得修改这个，必须要是新版本 | | desdescription | 对这个npm包的描述 | | main | 链接到这个包后，默认打开的文件 | | keywords | 关键词。若是自行使用，可以不配置 | | author | 作者。填写自己的用户名就行 |

现在在json文件中添加以下信息

"files": ["index.js", ""]

在[]中添加需要发布的文件或文件夹，多个文件或文件夹用,隔开并且每个都用""包裹。自行检查语法错误

发布

由于镜像源问题，我们可能会发布失败我们直接在cmd中切换镜像源

npm config set registry https://registry.npmjs.org

切换后发布

npm publish

发布成功后我们再将镜像源切换回

npm config set registry https://registry.npmmirror.com

若不切换，可能会出现 npm install 失败

访问文件

访问npm包的文件我们可以使用unpkg来访问以下链接是访问最新发布的npm包

https://unpkg.com/npm包名/file

若在包名后添加@版本号，则可以访问指定版本的npm包

# 准确版本号
https://unpkg.com/npm包名@1.1.1/file
# 模糊版本号(访问的是这个大版本的最新的版本号)
https://unpkg.com/npm包名@1/file
# 模糊版本号(访问的是这个小版本的最新的版本号)
https://unpkg.com/npm包名@1.1/file

好了，今天的分享就到这里了，拜拜！

StarRail-忘归人

Tue, 24 Dec 2024 11:38:04 GMT

Codeforces Round 991 (Div.3)

Fri, 06 Dec 2024 10:25:16 GMT

{% note blue 'fas fa-bullhorn' simple %}打过的最难的div3{% endnote %}

A.Line Breaks

Line Breaks

题目描述

{% tabs A %}

Kostya has a text s consisting of n words made up of Latin alphabet letters. He also has two strips on which he must write the text. The first strip can hold m characters, while the second can hold as many as needed.

Kostya must choose a number x and write the first x words from s on the first strip, while all the remaining words are written on the second strip. To save space, the words are written without gaps, but each word must be entirely on one strip.

Since space on the second strip is very valuable, Kostya asks you to choose the maximum possible number x such that all words s1,s2,…,sx fit on the first strip of length m.

一段文本有 $n$ 个单词，现将这段文本写在纸上，单词间无间隔，在第一页纸能写 $m$ 个字符，但是一个单词必须出现在同一页纸上。问：第一页纸能写多少个单词

{% endtabs %}

解题思路

模拟

参考代码

#include<bits/stdc++.h>

using i128 = __int128;
using i64 = long long;
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const i64 inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;
std::mt19937_64 rng(std::chrono::system_clock::now().time_since_epoch().count());

void solve() {
	int n, m, f = 1;
	std::cin >> n >> m;
	std::vector<std::string> s(n);
	for(int i = 0; i < n; i++) {
		std::cin >> s[i];
	}

	int su = 0, ct = 0;
	for(int i = 0; i < n; i++) {
		if (su + s[i].size() <= m) {
			ct++;
			su += (int) s[i].size();
		} else {
			break;
		}
	}
	std::cout << ct << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

B.Transfusion

Transfusion

题目描述

{% tabs B %}

You are given an array a of length n. In one operation, you can pick an index i from 2 to n−1 inclusive, and do one of the following actions:

Decrease $a_{i-1}$ by 1, then increase $a_{i+1}$ by 1.
Decrease $a_{i+1}$ by 1, then increase $a_{i-1}$ by 1.

After each operation, all the values must be non-negative. Can you make all the elements equal after any number of operations?

给定长度为 $n$ 的数组可以执行以下操作：

$a_{i-1}=a_{i-1}-1,a_{i+1}=a_{i+1}+1$;
$a_{i-1}=a_{i-1}+1,a_{i+1}=a_{i+1}-1$;

问：是否可以通过以上操作将数组的所有元素变为相等。

{% endtabs %}

解题思路

可以发现每次修改的下标奇偶性相同，我们可以分别记录下奇数下标和偶数下标的 $sum$ 和 $ct$。那么能实现的判断条件也很简单，如下：

$\frac{sum_{奇}}{ct_{奇}} = \frac {sum_{偶}}{ct_{偶}}$
$\frac{sum_{奇}}{ct_{奇}}=0 ，\frac{sum_{偶}}{ct_{偶}} =0$

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int, int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
  int n;
  std::cin >> n;
  std::vector<int> a(n);
  int ct[2]{}, sum[2]{};
  int s = 0;
  for (int i = 0; i < n; i++) {
    std::cin >> a[i];
    sum[i % 2] += a[i];
    ct[i % 2] ++;
  }

  if(sum[0] % ct[0] || sum[1] % ct[1] || sum[0] / ct[0] != sum[1] / ct[1]) {
    std::cout << "NO" << endl;
  }else {
    std::cout << "YES" << endl;
  }
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
  int Lazy_boy_ = 1;
  std::cin >> Lazy_boy_;
  while (Lazy_boy_--) solve();
  return 0;
}

C.Uninteresting Number

Uninteresting Number

题目描述

{% tabs C %}

You are given a number n with a length of no more than 105.

You can perform the following operation any number of times: choose one of its digits, square it, and replace the original digit with the result. The result must be a digit (that is, if you choose the digit x, then the value of x2 must be less than 10).

Is it possible to obtain a number that is divisible by 9 through these operations?

给你一个长度不超过 $10^5$ 的数字 $n$ 。

你可以多次进行下面的运算：选择其中一个数字，将其平方，然后用运算结果替换原来的数字。结果必须是一位数字(也就是说，如果您选择数字 $x$ ，那么 $x^2$ 的值必须小于 $10$ )。

通过这些运算，有可能得到一个能被 $9$ 整除的数吗？

{% endtabs %}

解题思路

数字必须是数字这一要求对变换有如下限制：我们可以将 $0$ 变换为 $0$ ，将 $1$ 变换为 $1$ ，将 $2$ 变换为 $4$ ，将 $3$ 变换为 $9$ 。任何其他数字的平方都会超过 9，因此无法变换。涉及 $0$ 和 $1$ 的变换都是无用的，因此我们有两种可能的操作：将数字 $2$ 或数字 $3$ 平方。

我们将使用 $9$ 的可除规则。它规定，当且仅当一个数字的数位之和能被 $9$ 整除时，这个数字才能被 $9$ 整除。让我们看看数字的位数之和在可能的变换中会发生怎样的变化。如果我们对 $2$ 进行平方运算，数位之和将增加 $2^2 - 2 = 2$ ；如果我们对 $3$ 进行平方运算，数位之和将增加 $3^2 - 3 = 6$ 。

我们将计算数字中 $2$ 的位数和数字中 $3$ 的位数。我们可以从可用的数位 $2$ 和 $3$ 中选择转换的个数。变换超过 8 个 2 和超过 8 个 3 的余数是没有意义的，因为它们的变换加到总和中的余数模 $9$ 会重复。

因此，最终的解法是这样的：我们计算数字的位数之和，数出 $2$ 和 $3$ 的位数。我们将遍历改变 $2$ 的位数（可能为 0，但不超过 8 位），以及改变 $3$ 的位数（可能为 0，但也不超过 8 位）。假设我们改变了 $x$ 位数 $2$ 和 $y$ 位数 $3$ ，那么这个数的位数总和就增加了 $x * 2 + y * 6$ 。如果新的和能被 $9$ 整除，那么答案就是 "是"。如果在迭代过程中从未出现过这种情况，则答案为 "否"。

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int, int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
  std::string s;
  std::cin >> s;
  int sum = 0, ct1 = 0, ct2 = 0;
  for (auto i : s) {
    sum += i - '0';
    ct1 += (i == '2' ? 1 : 0);
    ct2 += (i == '3' ? 1 : 0);
  }

  for (int i = 0; i <= std::min(9ll, ct1); i++) {
    for (int j = 0; j <= std::min(9ll, ct2); j++) {
      if ((sum + i * 2 + j * 6) % 9 == 0) {
        std::cout << "YES" << endl;
        return;
      }
    }
  }

  std::cout << "NO" << endl;
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
  int Lazy_boy_ = 1;
  std::cin >> Lazy_boy_;
  while (Lazy_boy_--) solve();
  return 0;
}

D.Digital string maximization

Digital string maximization

题目描述

{% tabs D %}

You are given a string s, consisting of digits from 0 to 9. In one operation, you can pick any digit in this string, except for 0 or the leftmost digit, decrease it by 1, and then swap it with the digit left to the picked.

For example, in one operation from the string 1023, you can get 1103 or 1022.

Find the lexicographically maximum string you can obtain after any number of operations.

给你一个由 0 到 9 的数字组成的字符串 s。在一次操作中，您可以选取该字符串中除 0 或最左边数字之外的任意一个数字，将其减少 1，然后将其与左边的数字对调。

例如，从字符串 1023 中进行一次运算，可以得到 1103 或 1022。

找出任意多次运算后可以得到的词性最大的字符串。

{% endtabs %}

解题思路

让我们看看数字 $s_i$ 。我们可以看到，我们不能将它向左移动超过 $s_i$ 次，因为它之后将是 $0$ 。因此，我们可以说，只有从 $i$ 到 $i+9$ 的指数上的数字才能位于指数 $i$ 上，因为最大的数字 $9$ 向左移动的次数不超过 $9$ 。

因此，我们可以对每个 $i$ 从 $s_i$ 到 $s_{i+9}$ 的所有数字进行暴力推理，选出 $j$ 中 $s_j - (j - i)$ 最大的数字；如果有多个最大选项，我们将最小化 $j$ 。之后，我们将 $s_j$ 向左移动，直到它位于索引 $i$ 上。

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int, int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
  std::string s;
  std::cin >> s;
  for (int i = 0; i < s.size(); i++) {
    int x = s[i] - '0', pos = i;
    for (int j = i; j < std::min(i + 10, (int)s.size()); j++) {
      if (s[j] - '0' - (j - i) > x) {
        x = s[j] - '0' - (j - i);
        pos = j;
      }
    }
    while (pos > i) {
      std::swap(s[pos], s[pos - 1]);
      pos--;
    }
    s[i] = x + '0';
  }
  std::cout << s << endl;
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
  int Lazy_boy_ = 1;
  std::cin >> Lazy_boy_;
  while (Lazy_boy_--) solve();
  return 0;
}

Atcoder beginner contest 378

Fri, 22 Nov 2024 13:38:05 GMT

A.Pairing

Pairing

题目描述

{% tabs A %}

There are four balls, and the color of the $i$-th ball is $A_i$. Find the maximum number of times you can perform this operation: choose two balls of the same color and discard both.

{% endtabs %}

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::map<int, int> mp;
	for(int i = 0; i < 4; i++) {
		int x;
		std::cin >> x;
		mp[x]++;
	}

	int s = 0;
	for(auto [x, y] : mp) {
		s += y / 2;
	}
	std::cout << s << endl;
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B.Garbage Collection

Garbage Collection

题目描述

{% tabs B %}

In AtCoder City, $N$ types of garbage are collected regularly. The $i$-th type of garbage $(i=1,2,\dots,N)$ is collected on days when the date modulo $q_i$ equals $r_i$. Answer $Q$ queries. In the $j$-th query $(j=1,2,\dots,Q)$, given that the $t_j$-th type of garbage is put out on day $d_j$, answer the next day on which it will be collected. Here, if the $i$-th type of garbage is put out on a day when that type of garbage is collected, then the garbage will be collected on the same day.

{% endtabs %}

解题思路

模拟

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<pii > a(n);
	for(int i = 0; i < n; i++) {
		int u, v;
		std::cin >> u >> v;
		a[i] = {u, v};
	}

	int q;
	std::cin >> q;
	while (q--) {
		int t, d;
		std::cin >> t >> d;
		t--;
		auto [x, y] = a[t];
		int w = d / x * x + y;
		if (w < d) w += x;
		std::cout << w << endl;
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C.Repeating

Repeating

题目描述

{% tabs C %}

You are given a sequence of $N$ positive numbers, $A = (A_1, A_2, \dots, A_N)$. Find the sequence $B = (B_1, B_2, \dots, B_N)$ of length $N$ defined as follows.

For $i = 1, 2, \dots, N$, define $B_i$ as follows: - Let $B_i$ be the most recent position before $i$ where an element equal to $A_i$ appeared. If such a position does not exist, let $B_i = -1$.
More precisely, if there exists a positive integer $j$ such that $A_i = A_j$ and $j < i$, let $B_i$ be the largest such $j$. If no such $j$ exists, let $B_i = -1$.

给你一个由 $N$ 个正数 $A = (A_1, A_2, \dots, A_N)$ 组成的数列。求长度为 $N$ 的序列 $B = (B_1, B_2, \dots, B_N)$ 的定义如下。

对于 $i = 1, 2, \dots, N$ ，定义 $B_i$ 如下：- 设 $B_i$ 是在 $i$ 之前出现过与 $A_i$ 相同元素的最近位置。如果不存在这样的位置，则设为 $B_i = -1$ 。
更确切地说，如果存在一个正整数 $j$ ，使得 $A_i = A_j$ 和 $j < i$ ，那么就让 $B_i$ 成为最大的 $j$ 。如果不存在这样的 $j$ , 则设 $B_i = -1$ . {% endtabs %}

解题思路

标记之前出现过的数的位置

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> a(n + 2), b(n + 2);
	std::map<int, int> mp;
	for(int i = 1; i <= n; i++) std::cin >> a[i];
	b[1] = -1;
	mp[a[1]] = 1;
	for(int i = 2; i <= n; i++) {
		if (mp.find(a[i]) != mp.end()) {
			b[i] = mp[a[i]];
		}else {
			b[i] = -1;
		}
		mp[a[i]] = i;
	}

	for(int i = 1; i <= n; i++) std::cout << b[i] << " \n"[i == n];
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

D.Count Simple Paths

Count Simple Paths

题目描述

{% tabs D %}

There is a grid of $H \times W$ cells. Let $(i, j)$ denote the cell at the $i$-th row from the top and the $j$-th column from the left. Cell $(i, j)$ is empty if $S_{i,j}$ is ., and blocked if it is #. Count the number of ways to start from an empty cell and make $K$ moves to adjacent cells (up, down, left, or right), without passing through blocked squares and not visiting the same cell more than once. Specifically, count the number of sequences of length $K+1$, $((i_0, j_0), (i_1, j_1), \dots, (i_K, j_K))$, satisfying the following.

$1 \leq i_k \leq H$, $1 \leq j_k \leq W$, and $S_{i_k, j_k}$ is ., for each $0 \leq k \leq K$.
$|i_{k+1} - i_k| + |j_{k+1} - j_k| = 1$ for each $0 \leq k \leq K-1$.
$(i_k, j_k) \neq (i_l, j_l)$ for each $0 \leq k < l \leq K$.

有一个由 $H \times W$ 个单元格组成的网格。让 $(i, j)$ 表示从上往下第 $i$ 行，从左往上第 $j$ 列的单元格。如果 $S_{i,j}$ 是 .，则单元格 $(i, j)$ 为空；如果是 # ，则单元格 $(i, j)$ 阻塞。计算从一个空单元格开始，向相邻单元格（向上、向下、向左或向右）进行 $K$ 移动，而不经过被阻塞的方格，并且不多次访问同一单元格的方法的数目。具体地说，计算满足以下条件的长度为 $K+1$ , $((i_0, j_0), (i_1, j_1), \dots, (i_K, j_K))$ 的序列的个数。

$1 \leq i_k \leq H$ 、 $1 \leq j_k \leq W$ 和 $S_{i_k, j_k}$ 为 .，每个 $0 \leq k \leq K$ 为 .。
$|i_{k+1} - i_k| + |j_{k+1} - j_k| = 1$ 为每个 $0 \leq k \leq K-1$ 。
每个 $0 \leq k < l \leq K$ 的 $(i_k, j_k) \neq (i_l, j_l)$ 。 {% endtabs %}

解题思路

dfs暴搜

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

void solve() {
	int n, m, k;
	std::cin >> n >> m >> k;
	std::vector<std::string> s(n);
	for(int i = 0; i < n; i++) std::cin >> s[i];

	auto check = [&](int x, int y) {
		return x >= 0 && x < n && y >= 0 && y < m;
	};

	int res = 0;

	std::vector vis(n, std::vector<bool>(m, false));
	std::function<void(int, int, int)> dfs = ([&](int x, int y, int val) {
		vis[x][y] = true;
		if (val == k) {
			res++;
			return;
		}
		for(int i = 0; i < 4; i++) {
			int u = x + dx[i], v = y + dy[i];
			if (check(u, v) && !vis[u][v] && s[u][v] == '.') {
				dfs(u, v, val + 1);
				vis[u][v] = false;
			}
		}
	});

	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			if (s[i][j] == '.')
				dfs(i, j, 0), vis[i][j] = false;
		}
	}
	std::cout << res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Atcoder beginner contest 376

Thu, 24 Oct 2024 09:59:57 GMT

A.Candy Button

Candy Button

题目描述

一个按钮，按了会发糖。

给定多次按的时间。如果这次按的时间距离上次发糖时间超过了$c$，则发个糖。问发的糖数量。

解题思路

发糖的前提是距离上次发糖时间大于等于$c$

参考代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
    int n, k, ct = 0;
    std::cin >> n >> k;
    std::vector<int> a(n);
    for(int i = 0 ; i <n ; i ++) {
        std::cin >> a[i];
    }
    ct = 1;
    int pos = 0;
    for(int i = 1; i < n; i ++) {
        if(a[i] - a[pos] >= k) {
            ct ++;
            pos = i;
        }
    }

    std::cout << ct << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--) solve();
    return 0;
}

B.Hands on Ring (Easy)

Hands on Ring (Easy)

题目描述

$n$的环形格子。两个棋子，初始位于$0$, $1$。给定 $q$个指令，每个指令指定一个棋子移动到某个格子上，期间不能移动另外一个棋子。依次执行这些指令，问移动的次数。

解题思路

简单模拟一下即可，可能我的代码有点“屎山”.

参考代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
    int n, q;
    std::cin >> n >> q;
    int res = 0;
    int l = 1, r = 2;
    while(q --) {
        char c;
        int x;
        std::cin >> c >> x;
        if(c == 'L' && x != l) {
            if(l < r) {
                if(x <= r) {
                    res += abs(x - l);
                }else {
                    res += (l + n - x);
                }
            }else {
                if(x >= r) {
                    res += abs(x - l);
                }else {
                    res += (x + n - l);
                }
            }
            l = x;
        }else if(c == 'R' && x != r){
            if(l < r) {
                if(x >= l) {
                    res += abs(r - x);
                }else {
                    res += (n - r + x);
                }
            }else {
                if(x <= l) {
                    res += abs(r - x);
                }else {
                    res += (r + n - x);
                }
            }
            r = x;
        }
    }

    std::cout << res << endl;
}


signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--) solve();
    return 0;
}

C.Prepare Another Box

Prepare Another Box

题目描述

给定 $n$个球的大小和$n - 1$个箱子的大小。现买一箱子，要求尺寸最小，使得 $n$个球恰好可以放进 $n$个箱子里,一个箱子有且只能放一个球。

解题思路

要求找出箱子大小的最小值，那么我们可以先排个序，若最后一个箱子越大，可以放入的方法就越多，反之越少。那么我们怎么求找到这个值呢？我们只需要一个箱子我们可以去尝试每一个大小箱子，但是这不现实，于是就可以想到二分，可以大大减小时间复杂度，二分条件便是查看是否有球无法放入箱子。二分完成后，要检查二分后的答案是否满足题意。

参考代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n), b(n - 1);
    for(int i = 0; i < n; i ++) {
        std::cin >> a[i];
    }

    for(int i = 0; i < n - 1; i ++) {
        std::cin >> b[i];
    }

    std::sort(a.begin(), a.end());
    std::sort(b.begin(), b.end());
    std::function<bool(int)> check = ([&](int x) -> bool {
        auto t = b;
        t.push_back(x);
        std::sort(t.begin(), t.end());
        for(int i = 0 ; i < n ; i ++) {
            if(a[i] > t[i]) return false;
        }
        return true;
    });

    int l = 1, r = inf;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(check(mid)) {
            r = mid;
        }else {
            l = mid + 1;
        }
    }
    if(l == inf) {
        std::cout << -1 << endl;
    }else{
        std::cout << l << endl;
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--) solve();
    return 0;
}

D.Cycle

Cycle

题目描述

给定一张有向图，问包含点$1$的环的最小环点数。

解题思路

要确保点数最小,且有回路，那么只有 $BFS$,从点 $1BFS$，每次到达点$1$时更新答案。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, m;
	std::cin >> n >> m;
	std::vector a(n + 1, std::vector<int>());

	for(int i = 0; i < m; i++) {
		int u, v;
		std::cin >> u >> v;
		a[u].push_back(v);
	}

	std::vector<int> dis(n + 1, -1ll);
	std::queue<int> q;
	dis[1] = 0;
	q.push(1);
    int res = inf;
	while (q.size()) {
		auto t = q.front();
		q.pop();
		for(auto i : a[t]) {
			if(i == 1) {
				res = std::min(res, dis[t] + 1);
			}
			if(dis[i] == -1) {
				dis[i] = dis[t] + 1;
				q.push(i);
			}
		}
	}
	if(res > n) {
		std::cout << -1 << endl;
	}else {
		std::cout << res << endl;
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	// std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

E.Max × Sum

Max × Sum

题目描述

给定$n$, $k$和两数组 $A$,$B$，$S$是大小为 $k$ 的 ${1,2,…,N}$ 的子集,求 $\max_{i \in S} A_{i} * \sum_{i \in S}B_{i}$ 的最小值。

解题思路

枚举$A_{i}$，剩下的问题就是找满足 $A_{j} \le A_{i}$的前$k-1$小的$B_{j}$的和。首先对数组 $A$进行排序，并且数组$B$与数组$A$一同变化（可以用pair）。然后依次枚举 $A_{i}$，此即为$\max_{i \in S} A_{i}$。然后找$1 \le j \le i$中最小的$k - 1$个$B_{i}$。考虑如何维护前 $k-1$小的和，因为会有不断的$B_{i}$加入，会不断淘汰较大的$B_{i}$，因此可以用优先队列维护这些 $B_{i}$在优先队列不断 push,pop时维护其里面的值的和即可。其时间复杂度为$O(n \log n)$注意枚举$A_{i}$时， $B_{i}$是一定要选的，因此要从优先队列里求出前$k - 1$小的和（但第$k$小的不能丢弃，它可能比$B_{i}$小，只是因为此时 $B_{i}$必选，因而暂时不能选它）。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, k;
	std::cin >> n >> k;

	std::vector<std::pair<int, int> > a(n);
	for(int i = 0; i < n; i++) {
		std::cin >> a[i].first;
	}

	for(int i = 0; i < n; i++) {
		std::cin >> a[i].second;
	}


	std::sort(a.begin(), a.end(), [&](pii aa, pii bb) {
		return aa.first < bb.first;
	});

	int s = 0;
	std::priority_queue<int, std::vector<int>, std::less<> > pq;
	for(int i = 0; i < k; i++) {
		pq.push(a[i].second);
		s += a[i].second;
    }

    int res = s * a[k - 1].first;
	for(int i = k; i < n; i++) {
		auto [x, y] = a[i];

		if (y < pq.top()) {
			s -= pq.top();
			pq.pop();
			pq.push(y);
			s += y;
		}

		res = std::min(res, s * x);
	}

	std::cout << res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

Atcoder beginner contest 377

Thu, 24 Oct 2024 09:59:57 GMT

A.Rearranging ABC

Rearranging ABC

题目描述

给定字符串$s$,判断是否可以组成 $ABC$

解题思路

排个序就行了

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::string s;
	std::cin >> s;
	std::sort(s.begin(), s.end());
	std::cout << (s == "ABC" ? "Yes" : "No") << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B.Avoid Rook Attack

Avoid Rook Attack

题目描述

给出棋盘，其中放有的位置为 #, 在放有棋子的上下左右四个方向不能放棋子，问有多少个位置可以放棋子.

解题思路

模拟下即可

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::vector<std::string> s(8, "");
	for(int i = 0; i < 8; i++) {
		std::cin >> s[i];
	}

	std::vector a(8, std::vector<int>(8, 1));
	for(int i = 0; i < 8; i++) {
		for(int j = 0; j < 8; j++) {
			if (s[i][j] == '#') {
				for(int l = 0; l < 8; l++) {
					a[i][l] = 0;
				}

				for(int l = 0; l < 8; l++) {
					a[l][j] = 0;
				}
			}
		}
	}
	int res = 0;
	for(auto i : a) {
		for(auto j : i) {
			res += j;
		}
	}

	std::cout << res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C.Avoid Knight Attack

Avoid Knight Attack

题目描述

给定$n * n$ 的棋盘和 $m$个棋子位置,其中棋子能走的位置上图所示,问多少个位置可以放棋子,并且不被吃掉

解题思路

模拟，需要注意边界处理

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, m;
	std::cin >> n >> m;

	int dx[] = {-2, -2, -1, -1, 1, 1, 2, 2},
			dy[] = {-1, 1, -2, 2, -2, 2, -1, 1};

	auto check = [&](int x, int y) {
		return 0 < x && x <= n && 0 < y && y <= n;
	};
	std::set<pii > se;
	for(int i = 0; i < m; i++) {
		int x, y;
		std::cin >> x >> y;
		se.insert({x, y});
		for(int j = 0; j < 8; j++) {
			int u = x + dx[j], v = y + dy[j];
			if (check(u, v)) se.insert({u, v});
		}
	}

	std::cout << n * n - se.size() << endl;

}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

D.Many Segments 2

Many Segments 2

题目描述

给你两个长度分别为 $N$ 、 $L=(L_1,L_2,\ldots,L_N)$ 和 $R=(R_1,R_2,\ldots,R_N)$ 的正整数序列，以及一个整数 $M$ 。求满足以下两个条件的整数对 $(l,r)$ 的个数：

$1\le l \le r \le M$
对于每一个 $1\le i\le N$ ，区间 $[l,r]$ 并不完全包含区间 $[L_i,R_i]$ 。

解题思路

考虑 $O(m)$的同时，维护一个左边界，就是当前位置能最多往前多少是刚好不完全覆盖的，最后这个左边界需要取个 max ，因为如果前面的左边界更右，那后面的左边界也要和前面一样。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, m;
	std::cin >> n >> m;

	std::vector<int> a(n + m, 1);
	for(int i = 0, l, r; i < n; i++) {
		std::cin >> l >> r;
		a[r] = std::max(a[r], l + 1);
	}

	for(int i = 1; i <= m; i++) {
		a[i] = std::max(a[i], a[i - 1]);
	}

	int res = 0;
	for(int i = 1; i <= m; i++) {
		res += i - a[i] + 1;
	}

	std::cout << res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

E.Permute K times 2

Permute K times 2

题目描述

给定长度为 $N$的数组 $P$,将 $P_{i}$替换为 $P_{P_{i}}$操作 $K$次,输出 $K$次操作后的数组.

解题思路

在替换时，某个数多替换几轮就可能回到替换前的位置，那么我们就只需要找出环的大小即可，随后再取模即可

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, k;
	std::cin >> n >> k;
	std::vector<int> P(n);

	for(int i = 0; i < n; i++) {
		std::cin >> P[i], P[i]--;
	}

	auto qpow = [&](int a, int b, int p) {
		int res = 1;
		while (b) {
			if (b & 1) res = res * a % p;
			a = a * a % p;
			b >>= 1;
		}
		return res;
	};

	std::vector<bool> vis(n, false);
	for(int i = 0; i < n; i++) {
		if (vis[i]) continue;
		int j = i;
		std::vector<int> t;
		while (!vis[j]) {
			vis[j] = true, t.push_back(j);
			j = P[j];
		}

		int w = qpow(2, k, t.size());
		for(int x = 0; x < t.size(); x++) {
			P[t[x]] = t[(x + w) % t.size()];
		}
	}

	for(int i = 0; i < n; i++) std::cout << P[i] + 1 << " \n"[i == n - 1];
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Atcoder beginner contest 374

Mon, 07 Oct 2024 14:07:03 GMT

A.Takahashi san 2

Takahashi san 2

题目描述

判断字符串末尾是否有 san 这个后缀

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::string s;
	std::cin >> s;
	std::string t = s.substr(s.size() - 3);
	std::cout << (t == "san" ? "Yes" : "No") << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B.Unvarnished Report

Unvarnished Report

题目描述

给定字符串 $S$ 和 $T$,若字符串 $S$ 和字符串 $T$ 完全相等,则输出 $0$ 否则输出 $S$ 和 $T$ 第一个不相同的位置.

解题思路

首先判断两个字符串是否相同,

若相同直接输出 $0$

否则用 $for$ 遍历一次字符串

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::string s, t;
	std::cin >> s >> t;
	if (s == t) {
		std::cout << 0 << endl;
		return;
	}
	for(int i = 0; i < std::max(s.size(), t.size()); i++) {
		if (s[i] != t[i]) {
			std::cout << i + 1 << endl;
			break;
		}
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C.Separated Lunch

Separated Lunch

题目描述

给出一个数 $n$, 和一个长度为 $n$ 的数组 $K$, 将这个数组划分为 $A$ , $B$两个部分,使得这两个部分的和 $S_{A}$ 和 $S_{B}$ 中的最大值最小

数据范围: $2 \leq n \leq 20$, $1 \leq K_{i} \leq 10^{8}$

解题思路

瞄一眼中文题面, 有点像 $01$ 背包, 但是你可以发现数据范围好像不能用背包，有没有其他方法呢?

好像 $n$ 的范围比较小，我们可以使用 $dfs$ 来搜索每一种情况，最多为 $2^{20}$,那么怎么判断哪种情况最优?只需要满足 $S_{A}$和 $S_{B}$ 的差值最小，答案即为差值最小时的最大值。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, w = 0;
	std::cin >> n;
	std::vector<int> a(n);
	for(int i = 0; i < n; i++) {
		std::cin >> a[i];
		w += a[i];
	}


	std::vector<int> f(n, 0);
	int mi = inf, ans = inf;
	std::function<void(int)> dfs = ([&](int u) {
		if (u >= n) {
			int s = 0;
			for(int i = 0; i < n; i++) {
				if (f[i]) {
					s += a[i];
				}
			}
			if (mi >= abs(w - s - s)) {
				mi = abs(w - s - s);
				ans = std::min(ans, std::max(s, w - s));
			}
			return;
		}
		f[u] = 1;
		dfs(u + 1);
		f[u] = 0;
		dfs(u + 1);
	});

	dfs(0);

	std::cout << ans << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

D.Laser Marking

Laser Marking

题目描述

在一个平面上给出 $n$ 条线段的起始点$(A_{i}, B_{i})$和终点$(C_{i}, D_{i})$ 现在要使用激光打印机打印这些线段,在打印线段时的移动速度为每秒 $T$ 个单位长度, 不打印的时候的移动速度为每秒 $S$ 个单位长度, 问打印这些线段的最短时间为多少？

解题思路

由于一个线段可以从两个端点中的任意一个开始打印，看来这个题又和上面一个题一样使用 $dfs$ ,循环初始到达线段,先移动到其中一个端点,再移动到另一个端点，答案记录下来，再$dfs$, $dfs$函数中的参数 $x$, $y$, $u$, $v$ 表示在此之前是从点$(x,y)$ 移动到了 $(u,v)$.其实 $dfs$ 只传当前位置就行了,只是个人方便识别.

参考代码

hypot()函数详解： hypot(x, y) 返回的是浮点型数据类型,值为 $\sqrt{x^{2} + y^{2}}$ 即将$x, y$作为直角三角形的两条直角边的斜边。 hypot(x,y,z) 返回类型同上值为 $\sqrt{x^{2} + y^{2} + z^{2}}$

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, s, t;
	std::cin >> n >> s >> t;
	std::vector<int> A(n), B(n), C(n), D(n);
	for(int i = 0; i < n; i++)
		std::cin >> A[i] >> B[i] >> C[i] >> D[i];

	std::vector<bool> vis(n, false);
	double ans = INFINITY, w = 0;
	auto check = [&]() -> bool {
		for(int i = 0; i < n; i++) if (!vis[i]) return false;
		return true;
	};

	std::function<void(int, int, int, int)> dfs = ([&](int x, int y, int u, int v) -> void {
		if (check()) {
			ans = std::min(ans, w);
//			std::cout << ans << endl;
			return;
		}

		for(int i = 0; i < n; i++) {
			if (!vis[i]) {
				vis[i] = true;
				auto t1 = std::hypot(u - A[i], v - B[i]) / s;
				auto t2 = std::hypot(u - C[i], v - D[i]) / s;
				auto tt = std::hypot(A[i] - C[i], B[i] - D[i]) / t;
				w += tt, w += t1;
				dfs(A[i], B[i], C[i], D[i]);
				w -= t1, w += t2;
				dfs(C[i], D[i], A[i], B[i]);
				w -= t2, w -= tt;
				vis[i] = false;
			}
		}
	});

	for(int i = 0; i < n; i++) {
		vis[i] = true;
		auto t1 = std::hypot(A[i], B[i]) / s;
		auto t2 = std::hypot(C[i], D[i]) / s;
		auto tt = std::hypot(A[i] - C[i], B[i] - D[i]) / t;
		w = t1 + tt;
		dfs(A[i], B[i], C[i], D[i]);
		w = t2 + tt;
		dfs(C[i], D[i], A[i], B[i]);
		vis[i] = false;
	}
	std::cout << fix(16) << ans << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Atcoder beginner contest 375

Mon, 07 Oct 2024 14:07:03 GMT

A.Seats

Seats

题目描述

给定字符串 $s$ 其中字符串只含有 # 和 . ,# 表示当前位置有人, .表示当前位置无人. 问:有多少个位置满足左右有人，当前位置无人的.

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::string s;
	std::cin >> s;
	int ct = 0;
	for(int i = 1; i < n - 1; i++) {
		if (s[i] == '.' && s[i] != s[i + 1] && s[i + 1] == s[i - 1])
			ct++;
	}
	std::cout << ct << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B.Traveling Takahashi Problem

Traveling Takahashi Problem

题目描述

给定$n$个点，从点 $(0,0)$ 出发依次经过这些点,然后回到原点的代价. 从点 $(a,b)$ 移动到点 $(c,d)$ 的代价是 $\sqrt{(a-c)^{2} + (b-d)^{2}}$

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	double s = 0;
	int n;
	std::cin >> n;
	int x = 0, y = 0;
	for(int i = 0; i < n; i++) {
		int u, v;
		std::cin >> u >> v;
		s += std::hypot(u - x, y - v);
		x = u, y = v;
	}
	s += std::hypot(x, y);
	std::cout << fix(16) << s << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C.Spiral Rotation

Spiral Rotation

题目描述

题意太复杂，直接说重点，在 $N * N$ 的矩阵中,每个单元格都涂成黑色或白色。如果 $A_{i, j} =$ 则 $(i, j)$ 单元格为黑色；如果是 $A_{i, j} =$ .，则为黑色。."，则为白色。

依次对 $i = 1, 2, \ldots, \frac{N}{2}$ 进行以下操作:

对于 $i$ 和 $N + 1 - i$ 之间的所有整数对 $x, y$ ，将单元格 $(y, N + 1 - x)$ 的颜色替换为单元格 $(x, y)$ 的颜色。同时对所有这些单元格对 $x, y$ 进行替换。最后打印这个矩阵。

解题思路

稍加推理就可以发现对于每次操作 $i$都是在对以 $(i,i)$为左上角，大小为 $(N-i+1)*(N-i+1)$ 的子矩阵进行顺时针旋转 $90^{\circ}$

参考代码

TLE code

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<std::string> s(n);
	for(int i = 0; i < n; i++) {
		std::cin >> s[i];
	}

	for(int a = 0; a < n / 2; a++) {
		auto t = s;
		for(int i = a; i < n - a; i++) {
			for(int j = a; j < n - a; j++) {
				t[i][j] = s[n - j - 1][i];
			}
		}
		s = t;
	}

	for(auto i : s) {
		std::cout << i << endl;
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

AC code

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int N;
	std::cin >> N;
	std::vector<std::string> A(N), B(N, std::string(N, ' '));
	for(int i = 0; i < N; i++)std::cin >> A[i];
	for(int d = 0; d < N / 2; d++) {
		for(int t = 0; t < (d + 1) % 4; t++) {
			for(int x = d; x < N - d; x++) {
				B[x][d] = A[x][d];
				B[x][N - d - 1] = A[x][N - d - 1];
				B[d][x] = A[d][x];
				B[N - d - 1][x] = A[N - d - 1][x];
			}
			for(int x = d; x < N - d; x++) {
				A[d][N - x - 1] = B[x][d];
				A[N - d - 1][N - x - 1] = B[x][N - d - 1];
				A[x][N - d - 1] = B[d][x];
				A[x][d] = B[N - d - 1][x];
			}
		}
	}
	for(auto i : A) {
		std::cout << i << endl;
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

D.ABA

ABA

题目描述

给你一个由大写英文字母组成的字符串 $S$ 。求满足以下两个条件的整数三元组 $(i, j, k)$ 的个数：

$1 \leq i < j < k \leq |S|$
将 $S_i$ 、 $S_j$ 和 $S_k$ 按此顺序连接而成的长度为 $3$ 的字符串是一个回文字符串。

这里， $|S|$ 表示 $S$ 的长度， $S_x$ 表示 $S$ 的 $x$ -th字符。

解题思路

这个其实就是前缀和维护当前位置前的每个字母个数和当前位置后的每个字母个数

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::string s;
	std::cin >> s;
	std::vector ct(26, std::vector<int>(s.size() + 1, 0ll));
	for(int i = 0; i < s.size(); i++) {
		ct[s[i] - 'A'][i]++;
	}

	for(int i = 0; i < 26; i++) {
		for(int j = 1; j < s.size(); j++) {
			ct[i][j] += ct[i][j - 1];
		}
	}
	int ans = 0;
	for(int i = 1; i < s.size() - 1; i++) {
		for(int j = 0; j < 26; j++) {
			ans += ct[j][i - 1] * (ct[j][s.size() - 1] - ct[j][i]);
		}
	}

	std::cout << ans << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Codeforces Round 971 (Div.4)

Wed, 04 Sep 2024 09:18:56 GMT

A. Minimize!

Minimize!

题目描述

{% tabs A %}

You are given two integers a and b (a≤b). Over all possible integer values of c (a≤c≤b), find the minimum value of (c−a)+(b−c).

给定数字 $a$ , $b$ ,一个数 $c$ 的取值范围为 $[a,b]$ 求 $(c-a)+(b-c)$ 的最小值

{% endtabs %}

解题思路

我们对等式化简 $(c-a)+(b-c) \to b-a$ 由此可见,等式的结果与 $c$ 的值无关

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int a, b;
	std::cin >> a >> b;
	std::cout << b - a << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

B.osu!mania

osu!mania

题目描述

{% tabs B %}

You are playing your favorite rhythm game, osu!mania. The layout of your beatmap consists of $n$ rows and 4 columns. Because notes at the bottom are closer, you will process the bottommost row first and the topmost row last. Each row will contain exactly one note, represented as a '#'. For each note 1,2,…,n, in the order of processing, output the column in which the note appears.

给定 $n$ 行 4 列的字符串,从下向上处理字符串，输出该行字符串的 # 的位置

{% endtabs %}

解题思路

中文题面说得很清楚,用STL中的find函数就可以了

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<std::string> s(n);
	for(int i = 0; i < n; i++) {
		std::cin >> s[i];
	}

	for(int i = n - 1; i >= 0; i--) {
		std::cout << s[i].find('#') + 1 << " \n"[i == 0];
	}
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

C.The Legend of Freya the Frog

The Legend of Freya the Frog

题目描述

{% tabs C %}

Freya the Frog is traveling on the 2D coordinate plane. She is currently at point (0,0) and wants to go to point (x,y). In one move, she chooses an integer d such that 0≤d≤k and jumps d spots forward in the direction she is facing.

Initially, she is facing the positive x direction. After every move, she will alternate between facing the positive x direction and the positive y direction (i.e., she will face the positive y direction on her second move, the positive x direction on her third move, and so on).

What is the minimum amount of moves she must perform to land on point (x,y)?

在一个二维平面中,当前位置处于点 $(0,0)$ , 在给定一个数 $k$,每次移动的距离为 $d (0 \le d \le k) $,并且每次移动方向是在 $x$ 和 $y$ 轴正方向之间交替. 问需要就次移动到达点 $(x,y)$?

{%endtabs %}

解题思路

分别考虑 $x$ 和 $y$ 两个方向，计算我们在每个方向上需要的跳转次数。我们在 $x$ 方向上需要的跳转数是 $\lceil \frac{x}{k} \rceil$ ，类似地，在 $y$ 方向上需要的跳转数是 $\lceil \frac{y}{k} \rceil$ 。现在，让我们试着将它们组合起来，求出跳转的总次数。让我们考虑以下几种情况：

$\lceil \frac{y}{k} \rceil \geq \lceil \frac{x}{k} \rceil$ .在这种情况下，需要在 $y$ 方向上进行 $\lceil \frac{y}{k} \rceil - \lceil \frac{x}{k} \rceil$ 次额外跳跃。在弗莱娅执行这些额外跳跃时，她会选择 $x$ 方向的 $d = 0$ 。总共需要 $2 \cdot \lceil \frac{y}{k} \rceil$ 次跳跃。

$\lceil \frac{x}{k} \rceil < \lceil \frac{y}{k} \rceil$ .我们可以使用与前一种情况相同的推理方法，但是有一个问题。由于弗莱娅一开始是朝向 $x$ 方向的，所以在最后一跳时，她不需要朝向 $y$ 方向跳。总共需要 $2 \cdot \lceil \frac{x}{k} \rceil - 1$ 次跳跃。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int x, y, k;
	std::cin >> x >> y >> k;

	x = (x + k - 1) / k;
	y = (y + k - 1) / k;

	std::cout << std::max(2 * x - 1, 2 * y) << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

D.Satyam and Counting

Satyam and Counting

题目描述

{% tabs D%}

Satyam is given $n$ distinct points on the 2D coordinate plane. It is guaranteed that $0 \leq y_i \leq 1$ for all given points $(x_i, y_i)$. How many different nondegenerate right triangles$^{\text{∗}}$ can be formed from choosing three different points as its vertices? Two triangles $a$ and $b$ are different if there is a point $v$ such that $v$ is a vertex of $a$ but not a vertex of $b$. $^{\text{∗}}$A nondegenerate right triangle has positive area and an interior $90^{\circ}$ angle.

给出 $n$ 个点的坐标, 并且点的位置至多两行,数据范围:$(0 \le x_{i} \le n, 0 \le y_{i} \le 1)$,问这些点能组成多少个直角三角形?

{% endtabs %}

解题思路

对于点 $(x,y)$形成直角三角形分为以下情况

以点 $(x,1-y)$ 为三角形的直角顶点,那么这个情况的三角形的个数为点 ($(x, 1-y)$ 的个数 -1)

以点 $(x,y)$ 为三角形的直角顶点,我们就需要判断点$(x-1,1-y)$ 和点 $(x+1,1-y)$ 是否存在,若存在则这样的三角形的个数为 $1$

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> x(n, 0ll), y(n, 0ll), cnt(2, 0ll);
	std::vector vis(n + 1, std::array<int, 2>{0, 0});
	for(int i = 0; i < n; i++) {
		std::cin >> x[i] >> y[i];
		cnt[y[i]]++;
		vis[x[i]][y[i]] = 1;
	}

	int res = 0;
	for(int i = 0; i < n; i++) {
		if (vis[x[i]][1 - y[i]]) {
			res += cnt[1 - y[i]] - 1;
		}
		if (x[i] > 0 && x[i] < n && vis[x[i] - 1][1 - y[i]] && vis[x[i] + 1][1 - y[i]]) {
			res++;
		}
	}

	std::cout << res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

Codeforces Round 967 (Div. 2)

Mon, 02 Sep 2024 19:26:28 GMT

A.Make All Equal

题目描述

{% tabs A %}

You are given a cyclic array $a_1,a_2,…,a_n$ . You can perform the following operation on a at most $n−1$ times:

Let m be the current size of a, you can choose any two adjacent elements where the previous one is no greater than the latter one (In particular, $a_m$ and $a_1$ are adjacent and $a_m$ is the previous one), and delete exactly one of them. In other words, choose an integer i ( $1 \le i \le m$ ) where $a_i \le a_{(i \mod m)+1}$ holds, and delete exactly one of $a_i$ or $a_{(i \mod m) + 1}$ from aa. Your goal is to find the minimum number of operations needed to make all elements in aa equal.

题目意思是想让我们用最少的操作次数删除数组中的元素获得数组中的数字全相等的数组。

{% endtabs %}

解题思路

由于需要最小的操作数，我们可以直接剩下数目最多的数字，于是就可以使用 STL 中的 map 完成此题

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::map<int, int> mp;
	for(int i = 0, x; i < n; i++) {
		std::cin >> x;
		mp[x]++;
	}

	int res = 0;
	for(auto [x, y] : mp) {
		res = std::max(res, y);
	}
	std::cout << n - res << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

Atcoder beginner contest 367

Sun, 25 Aug 2024 19:30:34 GMT

A Shout Everyday

题目

给定一个整数时间 A,一个人在B时间睡觉,C时间起床(24小时制),问A是否不在睡觉时间

解题思路

我们可以先判断B，C这个时间段是否是跨越两天的，若是跨越两天， A < B && A > C 才会不在这个时间段若未跨越两天 A < B || A > C 满足不在 B，C 时间段

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	int a, b, c;
	std::cin >> a >> b >> c;
	if (b > c) {
		if (a >= b || a <= c) {
			std::cout << "No" << endl;
		} else {
			std::cout << "Yes" << endl;
		}
	} else {
		if (a >= b && a <= c) {
			std::cout << "No" << endl;
		} else {
			std::cout << "Yes" << endl;
		}
	}
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B Cut .0

题目

一个实数 $X$ 已精确到小数点后第三位。请在下列条件下打印实数 $X$ 。

小数部分不能有尾数 "0"。
小数点后不能有多余的尾数。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	std::string s, t("");
	std::cin >> s;
	int cnt = 0, f = 0;
	for(auto i : s) {
		if (cnt == 3) {
			break;
		}
		cnt += f;
		if (i == '.') f = 1;
		t = t + i;
	}

	while (t.back() == '0') t.pop_back();
	if (t.back() == '.') t.pop_back();
	std::cout << t << endl;
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C Enumerate Sequences

题目

按升序排列打印所有满足以下条件的长度为 $N$ 的整数序列。

第 $i$ 个元素介于 $1$ 和 $R_i$ 之间。
所有元素之和是 $K$ 的倍数。

解题思路

由于每个数都介于$1$和 $R_i$之间，我们可以遍历每个位置的每个数，显然$DFS$可以做到那么回溯条件是什么呢？显然是走到第$N$个数，那么答案就只需要验证下这$N$个数的和是否为$K$的倍数

参考代码

#include<bits/stdc++.h>

using VI = std::vector<int>;
#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	int n, k;
	std::cin >> n >> k;
	VI a(n);
	std::vector<VI> ans;
	for(int i = 0; i < n; i++) {
		std::cin >> a[i];
	}

	VI w(n, 1ll);
	std::function<void (int)> dfs = ([&] (int u) {
		if (u == n) {
			int res = 0;
			for(auto i : w) res += i;
			if (res % k == 0) ans.push_back(w);
			return;
		}
		for(int i = 1; i <= a[u]; i++) {
			w[u] = i;
			dfs(u + 1);
		}
		return;
	});

	dfs(0);

	std::sort(ans.begin(), ans.end(), [&] (VI aa, VI bb) { return aa < bb; });

	for(auto q : ans) {
		for(auto i : q) {
			std::cout << i << ' ';
		}
		std::cout << endl;
	}
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

D Pedometer

题目

解题思路

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	int N, M;
	std::cin >> N >> M;

	std::vector<int> A(N);
	std::vector<int> pre(N + 1);
	for(int i = 0; i < N; i++) std::cin >> A[i], pre[i + 1] = pre[i] + A[i];

	std::map<int, int> cnt;
	int ans = 0;

	const int L = pre[N];

	for(int i = 0, j = 0; i < N; i++) {
		ans += cnt[(pre[i] - L % M + M) % M];
		ans += cnt[pre[i] % M]++;
	}

	std::cout << ans << endl;
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Atcoder beginner contest 373

Sun, 25 Aug 2024 19:30:34 GMT

A September

September

题目描述

有 $12$ 个字符串 $S_1, S_2, S_3, \cdots S_{12}$ 问有几个字符串满足 $S_{i} = i (1 \le i \le 12)$

太简单不需要解释

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int ct = 0;
	for(int i = 0; i < 12; i++) {
		std::string s;
		std::cin >> s;
		if (s.size() == i + 1) ct++;
	}
	std::cout << ct << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

B 1D Keyboard

1D Keyboard

题目描述

给定长度为 $26$ 的字符串，并且保证字符串每个英文字母只出现一次,当前第 $0$ 步时处于 $A$ 点, 问需要走多少步会使得字符串所走过的路径为 $ABC.....XYZ$.简单点说就是从 $A$ 点走到 $B$ 点,再到 $C$ 点,以此类推,知道 $Z$ 点,至少需要走多少步?

解题思路

由于字符串中一个字母只会出现一次,我们就可以将每个字母的位置记录下来,然后再依次算出相邻两个点的距离,即可得出答案.

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	std::string s;
	std::cin >> s;

	std::map<char, int> mp;
	for(int i = 0; i < s.size(); i++) {
		mp[s[i]] = i;
	}
	int now = mp['A'];
	int w = 0;
	mp.erase('A');
	for(auto [c, pos] : mp) {
		w += abs(now - pos);
		now = pos;
	}

	std::cout << w << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

C Max Ai+Bj

Max Ai+Bj

题目描述

给你两个整数序列 $A$ 和 $B$ ，每个长度为 $N$ 。请选择整数 $i, j$ $(1 \leq i, j \leq N)$ 使其长度最大化。 $(1 \leq i, j \leq N)$ 使 $A {i} + B{j}$ 的值最大。输出最大值。

解题思路

选择尽量大的 $i,j$ 使得 $A_{i} + B_{j}$最大,为了使得和最大,只需要分别选择两个数组的最大值，才能使得和最大。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> a(n), b(n);

	for(int i = 0, x; i < n; i++) {
		std::cin >> a[i];
	}
	for(int i = 0, x; i < n; i++) {
		std::cin >> b[i];
	}
	std::sort(a.begin(), a.end());
	std::sort(b.begin(), b.end());
	std::cout << a[n - 1] + b[n - 1] << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	solve();
	return 0;
}

Codeforces Round 974 (Div.3)

Thu, 22 Aug 2024 15:40:48 GMT

A. Robin Helps

Robin Helps

题目描述

{% tabs A %}

There is a little bit of the outlaw in everyone, and a little bit of the hero too. The heroic outlaw Robin Hood is famous for taking from the rich and giving to the poor. Robin encounters n people starting from the 1\-st and ending with the n\-th. The i\-th person has ai gold. If ai≥k, Robin will take all ai gold, and if ai\=0, Robin will give 1 gold if he has any. Robin starts with 0 gold. Find out how many people Robin gives gold to.

给定 $n$ 和 $k$ ,和一个长度为 $n$ 的数组 $a$ ,金币初始值为 0 当 $a_{i} \ge k$ 时,会将 $a_{i}$ 全部取走(即金币数+$a_{i}$), 若 $a_{i}=0$ 并且金币数不为 0 那么会给他一个金币,问最后给了多少人金币?

{% endtabs %}

解题思路

其实只需要将过程模拟下即可

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, k;
	std::cin >> n >> k;
	std::vector<int> a(n);
	for(int i = 0; i < n; i++) std::cin >> a[i];
	int s = 0, cnt = 0;
	for(int i = 0; i < n; i++) {
		if (a[i] >= k) {
			s += a[i];
		}
		if (a[i] == 0 && s) {
			s -= 1;
			cnt++;
		}
	}

	std::cout << cnt << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

B. Robin Hood and the Major Oak

Robin Hood and the Major Oak

题目描述

{% tabs B %}

In Sherwood, the trees are our shelter, and we are all children of the forest.

The Major Oak in Sherwood is known for its majestic foliage, which provided shelter to Robin Hood and his band of merry men and women.

The Major Oak grows ii new leaves in the i-th year. It starts with 1 leaf in year 1.

Leaves last for k years on the tree. In other words, leaves grown in year i last between years i and i+k−1 inclusive.

Robin considers even numbers lucky. Help Robin determine whether the Major Oak will have an even number of leaves in year n.

大橡树在第(i)年会长出两片新叶。第 1 年开始长 1 片叶子。

树叶在树上可以存活 k 年。换句话说，第 i 年长出的树叶在第 i 年和第 i+k-1 年(包括第 i+k-1 年)之间持续生长。

罗宾认为偶数是幸运数字。请帮助罗宾判断这棵橡树在第 n 年的叶子数是否为偶数。

{% endtabs %}

==数据范围:==

$$ 1 \le n \le 10^{9}, 1 \le k \le n $$

解题思路

由于一片树叶的存活期为 $k$ 我们不妨只看后面 $k$ 年的树叶, 对于第 $i$ 年的树叶数量为 $i^ {i}$ ,但是数据范围较大,容易 TLE 或者是爆 longlong ,怎么办呢? 我们可以观察出一个性质: 相同奇偶性的底数和指数的结果奇偶性不变,那么就可以将这个问题化解为 $[n-k+1, n]$ 这个区间的所有数的和

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, k;
	std::cin >> n >> k;
	int l = n - k + 1, r = n;
	int s = (l + r) * k / 2;
	if (s & 1) std::cout << "NO" << endl;
	else std::cout << "YES" << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

C. Robin Hood in Town

Robin Hood in Town

题目描述

{% tabs C %}

There are n people living in the town. Just now, the wealth of the i-th person was ai gold. But guess what? The richest person has found an extra pot of gold!

More formally, find an aj**=max(a1**,a2**,…,an**), change aj to aj**+**x, where x is a non-negative integer number of gold found in the pot. If there are multiple maxima, it can be any one of them.

A person is unhappy if their wealth is strictly less than half of the average wealth**∗**.

If strictly more than half of the total population n are unhappy, Robin Hood will appear by popular demand.

Determine the minimum value of x for Robin Hood to appear, or output **−**1 if it is impossible.

给定长度为 $n$ 的数组 $a$ ,现在要将数 $x$ 加在数组中的最大值上,使得整个数组中小于平均值的一半的数目大于 $\frac{n}{2}$ ,问数 $x$ 的最小值为多少?

{% endtabs %}

解题思路

打眼一看,二分没问题了已知是将 $x$ 加在最大值上,那么我们可以将数组进行排序,为了使得满足条件 $a_{i}<\frac{\sum_{i=1}^{n}a_{i}}{n2}$ 的数目大于 $\frac{n}{2}$ 那么就只需要在排序好的数组中找到前 $\frac{n}{2}$ 个最小值,只要这其中的最大值都比 $\frac{\sum_{i=1}^{n}a_{i}}{n2}$ 小,就可以满足条件.

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve() {
	int n, s = 0;
	std::cin >> n;
	std::vector<int> a(n);
	for(int i = 0; i < n; i++) std::cin >> a[i], s += a[i];
	if (n <= 2) {
		std::cout << -1 << endl;
		return;
	}
	std::sort(a.begin(), a.end());
	std::function<bool(int)> check = ([&](int x) -> bool {
		int cnt = 0;
		double t = (s + x * 1.0 ) / (n * 2);
		return a[n / 2] < t;
	});

	int l = 0, r = 1e16;
	while (l < r) {
		int mid = (l + r) >> 1;
		if (check(mid)) {
			r = mid;
		} else {
			l = mid + 1;
		}
	}

	std::cout << l << endl;
}

signed main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

Atcoder beginner contest 339

Thu, 15 Aug 2024 18:43:36 GMT

A TLD

题目描述

给定字符串s,输出字符串中.(点)后面的字符,若有多个.输出最后一个.的信息.

解题思路

有多种解法,可以暴力循环一次,或者用find()函数查找

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e9 + 1;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    std::string s;
    std::cin >> s;
    int pos = 0, t = -1;
    while ((pos = s.find('.', pos)) != -1)
        t = pos, pos++;
    std::cout << s.substr(t + 1) << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Langton's Takahashi

题目描述

给三个数n,m和k,其中n m代表n * m的矩阵,k代表操作数起始点在矩阵的(1,1),朝向为正上方对于每次操作:

当前位置为. 则将当前位置改为# 并且向右转,向前走一步.

当前位置为# 则将当前位置改为. 并且向左转,向前走一步. 打印出矩阵作为结果

解题思路

使用矩阵模拟下过程即可对于样例3 4 5模拟下初始状态x = 1, y = 1朝向正上方

$$ \begin{matrix} .&.&.\ .&.&.\ .&.&.\ .&.&.\ \end{matrix} $$

第一步,由于当前位置(1,1)为.那么就需要将当前位置变为#,并向右转,走一步到(1,2),朝向右

$$ \begin{matrix} #&.&.\ .&.&.\ .&.&.\ .&.&.\ \end{matrix} $$

第二步,由于当前位置(1,2)为.那么就需要将当前位置变为#,并向右转,走一步到(2,2),朝向下

$$ \begin{matrix} #&#&.\ .&.&.\ .&.&.\ .&.&.\ \end{matrix} $$

第三步,由于当前位置(2,2)为.那么就需要将当前位置变为#,并向右转,走一步到(2,2),朝向左

$$ \begin{matrix} #&#&.\ .&#&.\ .&.&.\ .&.&.\ \end{matrix} $$

第四步,由于当前位置(2,1)为.那么就需要将当前位置变为#,并向右转,走一步到(1,1),朝向上

$$ \begin{matrix} #&#&.\ #&#&.\ .&.&.\ .&.&.\ \end{matrix} $$

第五步,由于当前位置(1,1)为#那么就需要将当前位置变为.,并向左转,走一步到(1,3),朝向左 ,此处能到(1,3)是因为矩阵相当于上下,左右连通的.

$$ \begin{matrix} .&#&.\ #&#&.\ .&.&.\ .&.&.\ \end{matrix} $$

最后就得到了这样的矩阵.对于朝向的转换就需要一定的技巧,合理运用模(mod)的运算.

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e9 + 1;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;
    std::vector<std::string> s(n, std::string(m, '.'));
    int x = 0, y = 0;
    int dx[] = {0, 1, 0, -1},
            dy[] = {1, 0, -1, 0};
    int t = 3;
    while (k--) {
        if (s[x][y] == '.')
            s[x][y] = '#', t = (t + 1) % 4;
        else
            s[x][y] = '.', t = (t + 3) % 4;
        x = (x + n + dx[t]) % n;
        y = (y + m + dy[t]) % m;
    }
    for (int i = 0; i < n; i++)
        std::cout << s[i] << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Atcoder beginner contest 338

Thu, 15 Aug 2024 18:37:21 GMT

A Capitalized?

Capitalized?

题目描述

给定一个字符串s, 让我们判断是否满足首字母大写,其他字母小写的规则.

解题思路

直接用库函数islower()和isupper()模拟一下

参考代码

#include <bits/stdc++.h>

//#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 2e18 + 50, MOD = 10007;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    std::string s;
    std::cin >> s;
    if (islower(s[0])) {
        std::cout << "No\n";
        return;
    }
    for (int i = 1; i < s.size(); i++)
        if (isupper(s[i])) {
            std::cout << "No\n";
            return;
        }

    std::cout << "Yes\n";
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Frequency

题目描述

给定一字符串s, 输出出现次数最多字符,若有多个输出字典序较小的.

解题思路

我们可以用数据结构map来存储,并记录最大的数. 由于map会自动将键按从小到大排序,那么我们就只需要遍历一次map的数据,当遍历到次数与最大值相同时,直接输出字符即可. 同样,用其他的方法计数也可行

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 2e18 + 50, MOD = 10007;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    std::string s;
    std::cin >> s;
    int ma = 0;
    std::map<char, int> mp;
    for (auto i: s)
        mp[i]++, ma = std::max(ma, mp[i]);
    for (auto i: mp) {
        if (i.second == ma) {
            std::cout << i.first << endl;
            return;
        }
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Leftover Recipes

题目描述

我们现在有n中配料,分别有$q_i$, 我们需要完成两种菜,这两个菜所用的配料分别$a_i,b_i$ 问:我们最多能做多少个菜?

解题思路

假设我们做x个A菜,y个B菜,所花费的各个材料为$a_{i}x + b_iy$,由于n 的数据范围较小,我们可以直接暴力循环$x\le10^6$ ,然后判断下$p_i<a_i*x$和$b_i$就行了

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 2e18 + 50, MOD = 10007;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> q(n);
    auto a = q, b = q;
    for (int i = 0; i < n; i++) std::cin >> q[i];
    for (int i = 0; i < n; i++) std::cin >> a[i];
    for (int i = 0; i < n; i++) std::cin >> b[i];
    int ans = 0;
    for (int x = 0; x <= 1e6; x++){
        int y = INF;
        for(int i = 0; i < n; i ++){
            if(q[i] < 1ll * a[i] * x)
                y = -INF;
            else if(b[i] > 0)
                y = std::min(y, (q[i] - a[i] * x) / b[i]);
        }
        ans = std::max(ans, x + y);
    }
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Atcoder beginner contest 331

Thu, 15 Aug 2024 18:33:03 GMT

A Tomorrow

题目大意

一年由 M个月组成,从 1月到 M月，每个月由 D天组成，从 1天到 D天。问:在该日历中，年 y、月 m、日 d的下一天的日期？

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve(){
    int M, D;
    std::cin >> M >> D;
    int y, m, d;
    std::cin >> y >> m >> d;
    d ++;
    if(d > D){
        d -= D;
        m ++;
        if(m > M){
            m -= M;
            y ++;
        }
    }
    std::cout << y << " " << m << " " << d << endl;;
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

B Buy One Carton of Milk

题目大意

一包 6个蛋 S元, 一包 8个蛋 M元,一包 12个蛋 L元问:购买任意数量的每包鸡蛋时, 求至少购买 N个鸡蛋所需的最小价格?

解题思路

由于数据量比较小,我们可以直接三重循环暴力跑一遍.

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n, s, m, l;
    std::cin >> n >> s >> m >> l;
    int ans = INF;
    for(int i = 0 ; i <=100 ; i ++){
        for(int j = 0; j <= 100; j ++){
            for(int k = 0 ; k <= 100; k ++){
                int w = i * s + j * m + l * k;
                if(i * 6 + 8 * j + 12 * k >= n)
                    ans = std::min (ans, w);
            }
        }
    }
    std::cout << ans << endl;
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

C Sum of Numbers Greater Than Me

题目大意

给一个大小为 N的数组 A, 问: 数组 A中所有大于 A[i]的元素之和.

解题思路

B数组为输入的数组, 现有 s记录数组元素的总和,数组 A记录 B数组中大小为 i的元素个数为 A[i]个,我们在遍历一次 A数组,只要 A[i] > 0就可以将 A[i]赋值为 s - A[i] * i 当然,同时 s -= i * A[i] 最后,再遍历一次数组 B,输出 A[B[i]].

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n, s = 0, ans = 0,x;
    std::cin >> n;
    std::vector<int> a(1e6 + 50, 0ll), b(n, 0ll);
    for(int i = 0 ; i < n ; i ++)
        std::cin >> b[i], a[b[i]] ++, s += b[i];

    for(int i = 1 ; i <= 1000000 ;i ++){
        if(a[i]){
            s -= a[i] * i;
            a[i] = s;
        }
    }
    for(int i = 0 ; i < n ; i ++)
        std::cout << a[b[i]] << " ";

}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

jiangly算法模板收集

Thu, 08 Aug 2024 23:52:44 GMT

声明

2024.03.31 Update：新增《Splay（其三）》。

历史更新记录

2024.02.21 Update：文件层级重构，新增《后缀自动机（SuffixAutomaton 旧版）》、《回文自动机（PAM）》

龙年快乐~

2023.12.29 Update：新增《树状数组（Fenwick 新版）》。

2023.12.16 Update：新增《库函数重载》《二项式（Binomial 任意模数计算）》《线性基（Basis）》《线段树（其四）》《Splay（其二）》。

欢迎通过各种渠道向我投稿~

2023.11.02 Update：最新版本都更新在 GitHub 了，但是注意到有些群u貌似不方便Fan Qiang，于是现在跟进上了 GitHub 的项目进度。

自用！非本人原创，仅作整理归档。大部分代码来自于 CodeForces Jiangly 的提交，部分来自于GYM、牛客、Atcoder。文章博客链接，文章 GitHub 链接。

灵感参考链接：beiyouwuyanzu/cf_code_jiangly

一、杂类

01 - int128 输出流自定义

2023-03-20

using i128 = __int128;

std::ostream &operator<<(std::ostream &os, i128 n) {
    std::string s;
    while (n) {
        s += '0' + n % 10;
        n /= 10;
    }
    std::reverse(s.begin(), s.end());
    return os << s;
}

02 - 常用库函数重载

using i64 = long long;
using i128 = __int128;

i64 ceilDiv(i64 n, i64 m) {
    if (n >= 0) {
        return (n + m - 1) / m;
    } else {
        return n / m;
    }
}

i64 floorDiv(i64 n, i64 m) {
    if (n >= 0) {
        return n / m;
    } else {
        return (n - m + 1) / m;
    }
}

template<class T>
void chmax(T &a, T b) {
    if (a < b) {
        a = b;
    }
}

i128 gcd(i128 a, i128 b) {
    return b ? gcd(b, a % b) : a;
}

二、图与网络

01 - 强连通分量缩点（SCC）

2023-06-18

struct SCC {
    int n;
    std::vector<std::vector<int>> adj;
    std::vector<int> stk;
    std::vector<int> dfn, low, bel;
    int cur, cnt;

    SCC() {}
    SCC(int n) {
        init(n);
    }

    void init(int n) {
        this->n = n;
        adj.assign(n, {});
        dfn.assign(n, -1);
        low.resize(n);
        bel.assign(n, -1);
        stk.clear();
        cur = cnt = 0;
    }

    void addEdge(int u, int v) {
        adj[u].push_back(v);
    }

    void dfs(int x) {
        dfn[x] = low[x] = cur++;
        stk.push_back(x);

        for (auto y : adj[x]) {
            if (dfn[y] == -1) {
                dfs(y);
                low[x] = std::min(low[x], low[y]);
            } else if (bel[y] == -1) {
                low[x] = std::min(low[x], dfn[y]);
            }
        }

        if (dfn[x] == low[x]) {
            int y;
            do {
                y = stk.back();
                bel[y] = cnt;
                stk.pop_back();
            } while (y != x);
            cnt++;
        }
    }

    std::vector<int> work() {
        for (int i = 0; i < n; i++) {
            if (dfn[i] == -1) {
                dfs(i);
            }
        }
        return bel;
    }
};

02 - 割边与割边缩点（EBCC）

2023-05-11

std::set<std::pair<int, int>> E;

struct EBCC {
    int n;
    std::vector<std::vector<int>> adj;
    std::vector<int> stk;
    std::vector<int> dfn, low, bel;
    int cur, cnt;

    EBCC() {}
    EBCC(int n) {
        init(n);
    }

    void init(int n) {
        this->n = n;
        adj.assign(n, {});
        dfn.assign(n, -1);
        low.resize(n);
        bel.assign(n, -1);
        stk.clear();
        cur = cnt = 0;
    }

    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    void dfs(int x, int p) {
        dfn[x] = low[x] = cur++;
        stk.push_back(x);

        for (auto y : adj[x]) {
            if (y == p) {
                continue;
            }
            if (dfn[y] == -1) {
                E.emplace(x, y);
                dfs(y, x);
                low[x] = std::min(low[x], low[y]);
            } else if (bel[y] == -1 && dfn[y] < dfn[x]) {
                E.emplace(x, y);
                low[x] = std::min(low[x], dfn[y]);
            }
        }

        if (dfn[x] == low[x]) {
            int y;
            do {
                y = stk.back();
                bel[y] = cnt;
                stk.pop_back();
            } while (y != x);
            cnt++;
        }
    }

    std::vector<int> work() {
        dfs(0, -1);
        return bel;
    }

    struct Graph {
        int n;
        std::vector<std::pair<int, int>> edges;
        std::vector<int> siz;
        std::vector<int> cnte;
    };
    Graph compress() {
        Graph g;
        g.n = cnt;
        g.siz.resize(cnt);
        g.cnte.resize(cnt);
        for (int i = 0; i < n; i++) {
            g.siz[bel[i]]++;
            for (auto j : adj[i]) {
                if (bel[i] < bel[j]) {
                    g.edges.emplace_back(bel[i], bel[j]);
                } else if (i < j) {
                    g.cnte[bel[i]]++;
                }
            }
        }
        return g;
    }
};

03 - 二分图最大权匹配（MaxAssignment 基于KM）【久远】

2022-04-10

template<class T>
struct MaxAssignment {
    public:
        T solve(int nx, int ny, std::vector<std::vector<T>> a) {
            assert(0 <= nx && nx <= ny);
            assert(int(a.size()) == nx);
            for (int i = 0; i < nx; ++i) {
                assert(int(a[i].size()) == ny);
                for (auto x : a[i])
                    assert(x >= 0);
            }

            auto update = [&](int x) {
                for (int y = 0; y < ny; ++y) {
                    if (lx[x] + ly[y] - a[x][y] < slack[y]) {
                        slack[y] = lx[x] + ly[y] - a[x][y];
                        slackx[y] = x;
                    }
                }
            };

            costs.resize(nx + 1);
            costs[0] = 0;
            lx.assign(nx, std::numeric_limits<T>::max());
            ly.assign(ny, 0);
            xy.assign(nx, -1);
            yx.assign(ny, -1);
            slackx.resize(ny);
            for (int cur = 0; cur < nx; ++cur) {
                std::queue<int> que;
                visx.assign(nx, false);
                visy.assign(ny, false);
                slack.assign(ny, std::numeric_limits<T>::max());
                p.assign(nx, -1);

                for (int x = 0; x < nx; ++x) {
                    if (xy[x] == -1) {
                        que.push(x);
                        visx[x] = true;
                        update(x);
                    }
                }

                int ex, ey;
                bool found = false;
                while (!found) {
                    while (!que.empty() && !found) {
                        auto x = que.front();
                        que.pop();
                        for (int y = 0; y < ny; ++y) {
                            if (a[x][y] == lx[x] + ly[y] && !visy[y]) {
                                if (yx[y] == -1) {
                                    ex = x;
                                    ey = y;
                                    found = true;
                                    break;
                                }
                                que.push(yx[y]);
                                p[yx[y]] = x;
                                visy[y] = visx[yx[y]] = true;
                                update(yx[y]);
                            }
                        }
                    }
                    if (found)
                        break;

                    T delta = std::numeric_limits<T>::max();
                    for (int y = 0; y < ny; ++y)
                        if (!visy[y])
                            delta = std::min(delta, slack[y]);
                    for (int x = 0; x < nx; ++x)
                        if (visx[x])
                            lx[x] -= delta;
                    for (int y = 0; y < ny; ++y) {
                        if (visy[y]) {
                            ly[y] += delta;
                        } else {
                            slack[y] -= delta;
                        }
                    }
                    for (int y = 0; y < ny; ++y) {
                        if (!visy[y] && slack[y] == 0) {
                            if (yx[y] == -1) {
                                ex = slackx[y];
                                ey = y;
                                found = true;
                                break;
                            }
                            que.push(yx[y]);
                            p[yx[y]] = slackx[y];
                            visy[y] = visx[yx[y]] = true;
                            update(yx[y]);
                        }
                    }
                }

                costs[cur + 1] = costs[cur];
                for (int x = ex, y = ey, ty; x != -1; x = p[x], y = ty) {
                    costs[cur + 1] += a[x][y];
                    if (xy[x] != -1)
                        costs[cur + 1] -= a[x][xy[x]];
                    ty = xy[x];
                    xy[x] = y;
                    yx[y] = x;
                }
            }
            return costs[nx];
        }
        std::vector<int> assignment() {
            return xy;
        }
        std::pair<std::vector<T>, std::vector<T>> labels() {
            return std::make_pair(lx, ly);
        }
        std::vector<T> weights() {
            return costs;
        }
    private:
        std::vector<T> lx, ly, slack, costs;
        std::vector<int> xy, yx, p, slackx;
        std::vector<bool> visx, visy;
};

04 - 一般图最大匹配（Graph 带花树算法）【久远】

2021-12-24

struct Graph {
    int n;
    std::vector<std::vector<int>> e;
    Graph(int n) : n(n), e(n) {}
    void addEdge(int u, int v) {
        e[u].push_back(v);
        e[v].push_back(u);
    }
    std::vector<int> findMatching() {
        std::vector<int> match(n, -1), vis(n), link(n), f(n), dep(n);

        // disjoint set union
        auto find = [&](int u) {
            while (f[u] != u)
                u = f[u] = f[f[u]];
            return u;
        };

        auto lca = [&](int u, int v) {
            u = find(u);
            v = find(v);
            while (u != v) {
                if (dep[u] < dep[v])
                    std::swap(u, v);
                u = find(link[match[u]]);
            }
            return u;
        };

        std::queue<int> que;
        auto blossom = [&](int u, int v, int p) {
            while (find(u) != p) {
                link[u] = v;
                v = match[u];
                if (vis[v] == 0) {
                    vis[v] = 1;
                    que.push(v);
                }
                f[u] = f[v] = p;
                u = link[v];
            }
        };

        // find an augmenting path starting from u and augment (if exist)
        auto augment = [&](int u) {

            while (!que.empty())
                que.pop();

            std::iota(f.begin(), f.end(), 0);

            // vis = 0 corresponds to inner vertices, vis = 1 corresponds to outer vertices
            std::fill(vis.begin(), vis.end(), -1);

            que.push(u);
            vis[u] = 1;
            dep[u] = 0;

            while (!que.empty()){
                int u = que.front();
                que.pop();
                for (auto v : e[u]) {
                    if (vis[v] == -1) {

                        vis[v] = 0;
                        link[v] = u;
                        dep[v] = dep[u] + 1;

                        // found an augmenting path
                        if (match[v] == -1) {
                            for (int x = v, y = u, temp; y != -1; x = temp, y = x == -1 ? -1 : link[x]) {
                                temp = match[y];
                                match[x] = y;
                                match[y] = x;
                            }
                            return;
                        }

                        vis[match[v]] = 1;
                        dep[match[v]] = dep[u] + 2;
                        que.push(match[v]);

                    } else if (vis[v] == 1 && find(v) != find(u)) {
                        // found a blossom
                        int p = lca(u, v);
                        blossom(u, v, p);
                        blossom(v, u, p);
                    }
                }
            }

        };

        // find a maximal matching greedily (decrease constant)
        auto greedy = [&]() {

            for (int u = 0; u < n; ++u) {
                if (match[u] != -1)
                    continue;
                for (auto v : e[u]) {
                    if (match[v] == -1) {
                        match[u] = v;
                        match[v] = u;
                        break;
                    }
                }
            }
        };

        greedy();

        for (int u = 0; u < n; ++u)
            if (match[u] == -1)
                augment(u);

        return match;
    }
};

05 - TwoSat（2-Sat）

2023-09-29

struct TwoSat {
    int n;
    std::vector<std::vector<int>> e;
    std::vector<bool> ans;
    TwoSat(int n) : n(n), e(2 * n), ans(n) {}
    void addClause(int u, bool f, int v, bool g) {
        e[2 * u + !f].push_back(2 * v + g);
        e[2 * v + !g].push_back(2 * u + f);
    }
    bool satisfiable() {
        std::vector<int> id(2 * n, -1), dfn(2 * n, -1), low(2 * n, -1);
        std::vector<int> stk;
        int now = 0, cnt = 0;
        std::function<void(int)> tarjan = [&](int u) {
            stk.push_back(u);
            dfn[u] = low[u] = now++;
            for (auto v : e[u]) {
                if (dfn[v] == -1) {
                    tarjan(v);
                    low[u] = std::min(low[u], low[v]);
                } else if (id[v] == -1) {
                    low[u] = std::min(low[u], dfn[v]);
                }
            }
            if (dfn[u] == low[u]) {
                int v;
                do {
                    v = stk.back();
                    stk.pop_back();
                    id[v] = cnt;
                } while (v != u);
                ++cnt;
            }
        };
        for (int i = 0; i < 2 * n; ++i) if (dfn[i] == -1) tarjan(i);
        for (int i = 0; i < n; ++i) {
            if (id[2 * i] == id[2 * i + 1]) return false;
            ans[i] = id[2 * i] > id[2 * i + 1];
        }
        return true;
    }
    std::vector<bool> answer() { return ans; }
};

06A - 最大流（Flow 旧版其一，整数应用）

2022-09-03

template<class T>
struct Flow {
    const int n;
    struct Edge {
        int to;
        T cap;
        Edge(int to, T cap) : to(to), cap(cap) {}
    };
    std::vector<Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<int> cur, h;
    Flow(int n) : n(n), g(n) {}

    bool bfs(int s, int t) {
        h.assign(n, -1);
        std::queue<int> que;
        h[s] = 0;
        que.push(s);
        while (!que.empty()) {
            const int u = que.front();
            que.pop();
            for (int i : g[u]) {
                auto [v, c] = e[i];
                if (c > 0 && h[v] == -1) {
                    h[v] = h[u] + 1;
                    if (v == t) {
                        return true;
                    }
                    que.push(v);
                }
            }
        }
        return false;
    }

    T dfs(int u, int t, T f) {
        if (u == t) {
            return f;
        }
        auto r = f;
        for (int &i = cur[u]; i < int(g[u].size()); ++i) {
            const int j = g[u][i];
            auto [v, c] = e[j];
            if (c > 0 && h[v] == h[u] + 1) {
                auto a = dfs(v, t, std::min(r, c));
                e[j].cap -= a;
                e[j ^ 1].cap += a;
                r -= a;
                if (r == 0) {
                    return f;
                }
            }
        }
        return f - r;
    }
    void addEdge(int u, int v, T c) {
        g[u].push_back(e.size());
        e.emplace_back(v, c);
        g[v].push_back(e.size());
        e.emplace_back(u, 0);
    }
    T maxFlow(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {
            cur.assign(n, 0);
            ans += dfs(s, t, std::numeric_limits<T>::max());
        }
        return ans;
    }
};

06B - 最大流（Flow 旧版其二，浮点数应用）

2022-04-09

template<class T>
struct Flow {
    const int n;
    struct Edge {
        int to;
        T cap;
        Edge(int to, T cap) : to(to), cap(cap) {}
    };
    std::vector<Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<int> cur, h;
    Flow(int n) : n(n), g(n) {}

    bool bfs(int s, int t) {
        h.assign(n, -1);
        std::queue<int> que;
        h[s] = 0;
        que.push(s);
        while (!que.empty()) {
            const int u = que.front();
            que.pop();
            for (int i : g[u]) {
                auto [v, c] = e[i];
                if (c > 0 && h[v] == -1) {
                    h[v] = h[u] + 1;
                    if (v == t) {
                        return true;
                    }
                    que.push(v);
                }
            }
        }
        return false;
    }

    T dfs(int u, int t, T f) {
        if (u == t) {
            return f;
        }
        auto r = f;
        double res = 0;
        for (int &i = cur[u]; i < int(g[u].size()); ++i) {
            const int j = g[u][i];
            auto [v, c] = e[j];
            if (c > 0 && h[v] == h[u] + 1) {
                auto a = dfs(v, t, std::min(r, c));
                res += a;
                e[j].cap -= a;
                e[j ^ 1].cap += a;
                r -= a;
                if (r == 0) {
                    return f;
                }
            }
        }
        return res;
    }
    void addEdge(int u, int v, T c) {
        g[u].push_back(e.size());
        e.emplace_back(v, c);
        g[v].push_back(e.size());
        e.emplace_back(u, 0);
    }
    T maxFlow(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {
            cur.assign(n, 0);
            ans += dfs(s, t, 1E100);
        }
        return ans;
    }
};

06C - 最大流（MaxFlow 新版）

2023-07-21

constexpr int inf = 1E9;
template<class T>
struct MaxFlow {
    struct _Edge {
        int to;
        T cap;
        _Edge(int to, T cap) : to(to), cap(cap) {}
    };

    int n;
    std::vector<_Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<int> cur, h;

    MaxFlow() {}
    MaxFlow(int n) {
        init(n);
    }

    void init(int n) {
        this->n = n;
        e.clear();
        g.assign(n, {});
        cur.resize(n);
        h.resize(n);
    }

    bool bfs(int s, int t) {
        h.assign(n, -1);
        std::queue<int> que;
        h[s] = 0;
        que.push(s);
        while (!que.empty()) {
            const int u = que.front();
            que.pop();
            for (int i : g[u]) {
                auto [v, c] = e[i];
                if (c > 0 && h[v] == -1) {
                    h[v] = h[u] + 1;
                    if (v == t) {
                        return true;
                    }
                    que.push(v);
                }
            }
        }
        return false;
    }

    T dfs(int u, int t, T f) {
        if (u == t) {
            return f;
        }
        auto r = f;
        for (int &i = cur[u]; i < int(g[u].size()); ++i) {
            const int j = g[u][i];
            auto [v, c] = e[j];
            if (c > 0 && h[v] == h[u] + 1) {
                auto a = dfs(v, t, std::min(r, c));
                e[j].cap -= a;
                e[j ^ 1].cap += a;
                r -= a;
                if (r == 0) {
                    return f;
                }
            }
        }
        return f - r;
    }
    void addEdge(int u, int v, T c) {
        g[u].push_back(e.size());
        e.emplace_back(v, c);
        g[v].push_back(e.size());
        e.emplace_back(u, 0);
    }
    T flow(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {
            cur.assign(n, 0);
            ans += dfs(s, t, std::numeric_limits<T>::max());
        }
        return ans;
    }

    std::vector<bool> minCut() {
        std::vector<bool> c(n);
        for (int i = 0; i < n; i++) {
            c[i] = (h[i] != -1);
        }
        return c;
    }

    struct Edge {
        int from;
        int to;
        T cap;
        T flow;
    };
    std::vector<Edge> edges() {
        std::vector<Edge> a;
        for (int i = 0; i < e.size(); i += 2) {
            Edge x;
            x.from = e[i + 1].to;
            x.to = e[i].to;
            x.cap = e[i].cap + e[i + 1].cap;
            x.flow = e[i + 1].cap;
            a.push_back(x);
        }
        return a;
    }
};

07A - 费用流（MCFGraph 最小费用可行流）

2022-12-12

struct MCFGraph {
    struct Edge {
        int v, c, f;
        Edge(int v, int c, int f) : v(v), c(c), f(f) {}
    };
    const int n;
    std::vector<Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<i64> h, dis;
    std::vector<int> pre;
    bool dijkstra(int s, int t) {
        dis.assign(n, std::numeric_limits<i64>::max());
        pre.assign(n, -1);
        std::priority_queue<std::pair<i64, int>, std::vector<std::pair<i64, int>>, std::greater<std::pair<i64, int>>> que;
        dis[s] = 0;
        que.emplace(0, s);
        while (!que.empty()) {
            i64 d = que.top().first;
            int u = que.top().second;
            que.pop();
            if (dis[u] < d) continue;
            for (int i : g[u]) {
                int v = e[i].v;
                int c = e[i].c;
                int f = e[i].f;
                if (c > 0 && dis[v] > d + h[u] - h[v] + f) {
                    dis[v] = d + h[u] - h[v] + f;
                    pre[v] = i;
                    que.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != std::numeric_limits<i64>::max();
    }
    MCFGraph(int n) : n(n), g(n) {}
    void addEdge(int u, int v, int c, int f) {
        if (f < 0) {
            g[u].push_back(e.size());
            e.emplace_back(v, 0, f);
            g[v].push_back(e.size());
            e.emplace_back(u, c, -f);
        } else {
            g[u].push_back(e.size());
            e.emplace_back(v, c, f);
            g[v].push_back(e.size());
            e.emplace_back(u, 0, -f);
        }
    }
    std::pair<int, i64> flow(int s, int t) {
        int flow = 0;
        i64 cost = 0;
        h.assign(n, 0);
        while (dijkstra(s, t)) {
            for (int i = 0; i < n; ++i) h[i] += dis[i];
            int aug = std::numeric_limits<int>::max();
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) aug = std::min(aug, e[pre[i]].c);
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
                e[pre[i]].c -= aug;
                e[pre[i] ^ 1].c += aug;
            }
            flow += aug;
            cost += i64(aug) * h[t];
        }
        return std::make_pair(flow, cost);
    }
};

07B - 费用流（MCFGraph 最小费用最大流）

代码同上，但是需要注释掉建边限制。以下为参考：

void addEdge(int u, int v, int c, int f) { // 可行流
    if (f < 0) {
        g[u].push_back(e.size());
        e.emplace_back(v, 0, f);
        g[v].push_back(e.size());
        e.emplace_back(u, c, -f);
    } else {
        g[u].push_back(e.size());
        e.emplace_back(v, c, f);
        g[v].push_back(e.size());
        e.emplace_back(u, 0, -f);
    }
}

void addEdge(int u, int v, int c, int f) { // 最大流
    g[u].push_back(e.size());
    e.emplace_back(v, c, f);
    g[v].push_back(e.size());
    e.emplace_back(u, 0, -f);
}

08 - 树链剖分（HLD）

2023-08-31

struct HLD {
    int n;
    std::vector<int> siz, top, dep, parent, in, out, seq;
    std::vector<std::vector<int>> adj;
    int cur;

    HLD() {}
    HLD(int n) {
        init(n);
    }
    void init(int n) {
        this->n = n;
        siz.resize(n);
        top.resize(n);
        dep.resize(n);
        parent.resize(n);
        in.resize(n);
        out.resize(n);
        seq.resize(n);
        cur = 0;
        adj.assign(n, {});
    }
    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    void work(int root = 0) {
        top[root] = root;
        dep[root] = 0;
        parent[root] = -1;
        dfs1(root);
        dfs2(root);
    }
    void dfs1(int u) {
        if (parent[u] != -1) {
            adj[u].erase(std::find(adj[u].begin(), adj[u].end(), parent[u]));
        }

        siz[u] = 1;
        for (auto &v : adj[u]) {
            parent[v] = u;
            dep[v] = dep[u] + 1;
            dfs1(v);
            siz[u] += siz[v];
            if (siz[v] > siz[adj[u][0]]) {
                std::swap(v, adj[u][0]);
            }
        }
    }
    void dfs2(int u) {
        in[u] = cur++;
        seq[in[u]] = u;
        for (auto v : adj[u]) {
            top[v] = v == adj[u][0] ? top[u] : v;
            dfs2(v);
        }
        out[u] = cur;
    }
    int lca(int u, int v) {
        while (top[u] != top[v]) {
            if (dep[top[u]] > dep[top[v]]) {
                u = parent[top[u]];
            } else {
                v = parent[top[v]];
            }
        }
        return dep[u] < dep[v] ? u : v;
    }

    int dist(int u, int v) {
        return dep[u] + dep[v] - 2 * dep[lca(u, v)];
    }

    int jump(int u, int k) {
        if (dep[u] < k) {
            return -1;
        }

        int d = dep[u] - k;

        while (dep[top[u]] > d) {
            u = parent[top[u]];
        }

        return seq[in[u] - dep[u] + d];
    }

    bool isAncester(int u, int v) {
        return in[u] <= in[v] && in[v] < out[u];
    }

    int rootedParent(int u, int v) {
        std::swap(u, v);
        if (u == v) {
            return u;
        }
        if (!isAncester(u, v)) {
            return parent[u];
        }
        auto it = std::upper_bound(adj[u].begin(), adj[u].end(), v, [&](int x, int y) {
            return in[x] < in[y];
        }) - 1;
        return *it;
    }

    int rootedSize(int u, int v) {
        if (u == v) {
            return n;
        }
        if (!isAncester(v, u)) {
            return siz[v];
        }
        return n - siz[rootedParent(u, v)];
    }

    int rootedLca(int a, int b, int c) {
        return lca(a, b) ^ lca(b, c) ^ lca(c, a);
    }
};

三、数论、几何、多项式

01 - 快速幂

2023-10-09

int power(int a, i64 b, int p) {
    int res = 1;
    for (; b; b /= 2, a = 1LL * a * a % p) {
        if (b % 2) {
            res = 1LL * res * a % p;
        }
    }
    return res;
}

02 - 欧拉筛

2023-08-29

std::vector<int> minp, primes;

void sieve(int n) {
    minp.assign(n + 1, 0);
    primes.clear();

    for (int i = 2; i <= n; i++) {
        if (minp[i] == 0) {
            minp[i] = i;
            primes.push_back(i);
        }

        for (auto p : primes) {
            if (i * p > n) {
                break;
            }
            minp[i * p] = p;
            if (p == minp[i]) {
                break;
            }
        }
    }
}

03 - 莫比乌斯函数筛（莫比乌斯函数/反演）

2023-03-04

std::unordered_map<int, Z> fMu;

constexpr int N = 1E7;
std::vector<int> minp, primes;
std::vector<Z> mu;

void sieve(int n) {
    minp.assign(n + 1, 0);
    mu.resize(n);
    primes.clear();

    mu[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (minp[i] == 0) {
            mu[i] = -1;
            minp[i] = i;
            primes.push_back(i);
        }

        for (auto p : primes) {
            if (i * p > n) {
                break;
            }
            minp[i * p] = p;
            if (p == minp[i]) {
                break;
            }
            mu[i * p] = -mu[i];
        }
    }

    for (int i = 1; i <= n; i++) {
        mu[i] += mu[i - 1];
    }
}


Z sumMu(int n) {
    if (n <= N) {
        return mu[n];
    }
    if (fMu.count(n)) {
        return fMu[n];
    }
    if (n == 0) {
        return 0;
    }
    Z ans = 1;
    for (int l = 2, r; l <= n; l = r + 1) {
        r = n / (n / l);
        ans -= (r - l + 1) * sumMu(n / l);
    }
    return ans;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    sieve(N);

    int L, R;
    std::cin >> L >> R;
    L -= 1;

    Z ans = 0;
    for (int l = 1, r; l <= R; l = r + 1) {
        r = R / (R / l);
        if (l <= L) {
            r = std::min(r, L / (L / l));
        }

        ans += (power(Z(2), R / l - L / l) - 1) * (sumMu(r) - sumMu(l - 1));
    }

    std::cout << ans << "\n";

    return 0;
}

04 - 求解单个数的欧拉函数

2023-10-09

int phi(int n) {
    int res = n;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            while (n % i == 0) {
                n /= i;
            }
            res = res / i * (i - 1);
        }
    }
    if (n > 1) {
        res = res / n * (n - 1);
    }
    return res;
}

05 - 扩展欧几里得（exGCD）

2023-10-09

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}

06 - 组合数（Comb+MInt & MLong）

2023-08-26

struct Comb {
    int n;
    std::vector<Z> _fac;
    std::vector<Z> _invfac;
    std::vector<Z> _inv;

    Comb() : n{0}, _fac{1}, _invfac{1}, _inv{0} {}
    Comb(int n) : Comb() {
        init(n);
    }

    void init(int m) {
        m = std::min(m, Z::getMod() - 1);
        if (m <= n) return;
        _fac.resize(m + 1);
        _invfac.resize(m + 1);
        _inv.resize(m + 1);

        for (int i = n + 1; i <= m; i++) {
            _fac[i] = _fac[i - 1] * i;
        }
        _invfac[m] = _fac[m].inv();
        for (int i = m; i > n; i--) {
            _invfac[i - 1] = _invfac[i] * i;
            _inv[i] = _invfac[i] * _fac[i - 1];
        }
        n = m;
    }

    Z fac(int m) {
        if (m > n) init(2 * m);
        return _fac[m];
    }
    Z invfac(int m) {
        if (m > n) init(2 * m);
        return _invfac[m];
    }
    Z inv(int m) {
        if (m > n) init(2 * m);
        return _inv[m];
    }
    Z binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fac(n) * invfac(m) * invfac(n - m);
    }
} comb;

07 - 二项式（Binomial 任意模数计算）

2023-08-22

std::vector<std::pair<int, int>> factorize(int n) {
    std::vector<std::pair<int, int>> factors;
    for (int i = 2; static_cast<long long>(i) * i <= n; i++) {
        if (n % i == 0) {
            int t = 0;
            for (; n % i == 0; n /= i)
                ++t;
            factors.emplace_back(i, t);
        }
    }
    if (n > 1)
        factors.emplace_back(n, 1);
    return factors;
}
constexpr int power(int base, i64 exp) {
    int res = 1;
    for (; exp > 0; base *= base, exp /= 2) {
        if (exp % 2 == 1) {
            res *= base;
        }
    }
    return res;
}
constexpr int power(int base, i64 exp, int mod) {
    int res = 1 % mod;
    for (; exp > 0; base = 1LL * base * base % mod, exp /= 2) {
        if (exp % 2 == 1) {
            res = 1LL * res * base % mod;
        }
    }
    return res;
}
int inverse(int a, int m) {
    int g = m, r = a, x = 0, y = 1;
    while (r != 0) {
        int q = g / r;
        g %= r;
        std::swap(g, r);
        x -= q * y;
        std::swap(x, y);
    }
    return x < 0 ? x + m : x;
}
int solveModuloEquations(const std::vector<std::pair<int, int>> &e) {
    int m = 1;
    for (std::size_t i = 0; i < e.size(); i++) {
        m *= e[i].first;
    }
    int res = 0;
    for (std::size_t i = 0; i < e.size(); i++) {
        int p = e[i].first;
        res = (res + 1LL * e[i].second * (m / p) * inverse(m / p, p)) % m;
    }
    return res;
}
constexpr int N = 1E5;
class Binomial {
    const int mod;
private:
    const std::vector<std::pair<int, int>> factors;
    std::vector<int> pk;
    std::vector<std::vector<int>> prod;
    static constexpr i64 exponent(i64 n, int p) {
        i64 res = 0;
        for (n /= p; n > 0; n /= p) {
            res += n;
        }
        return res;
    }
    int product(i64 n, std::size_t i) {
        int res = 1;
        int p = factors[i].first;
        for (; n > 0; n /= p) {
            res = 1LL * res * power(prod[i].back(), n / pk[i], pk[i]) % pk[i] * prod[i][n % pk[i]] % pk[i];
        }
        return res;
    }
public:
    Binomial(int mod) : mod(mod), factors(factorize(mod)) {
        pk.resize(factors.size());
        prod.resize(factors.size());
        for (std::size_t i = 0; i < factors.size(); i++) {
            int p = factors[i].first;
            int k = factors[i].second;
            pk[i] = power(p, k);
            prod[i].resize(std::min(N + 1, pk[i]));
            prod[i][0] = 1;
            for (int j = 1; j < prod[i].size(); j++) {
                if (j % p == 0) {
                    prod[i][j] = prod[i][j - 1];
                } else {
                    prod[i][j] = 1LL * prod[i][j - 1] * j % pk[i];
                }
            }
        }
    }
    int operator()(i64 n, i64 m) {
        if (n < m || m < 0) {
            return 0;
        }
        std::vector<std::pair<int, int>> ans(factors.size());
        for (int i = 0; i < factors.size(); i++) {
            int p = factors[i].first;
            int k = factors[i].second;
            int e = exponent(n, p) - exponent(m, p) - exponent(n - m, p);
            if (e >= k) {
                ans[i] = std::make_pair(pk[i], 0);
            } else {
                int pn = product(n, i);
                int pm = product(m, i);
                int pd = product(n - m, i);
                int res = 1LL * pn * inverse(pm, pk[i]) % pk[i] * inverse(pd, pk[i]) % pk[i] * power(p, e) % pk[i];
                ans[i] = std::make_pair(pk[i], res);
            }
        }
        return solveModuloEquations(ans);
    }
};

08 - 素数测试与因式分解（Miller-Rabin & Pollard-Rho）

2023-05-16

i64 mul(i64 a, i64 b, i64 m) {
    return static_cast<__int128>(a) * b % m;
}
i64 power(i64 a, i64 b, i64 m) {
    i64 res = 1 % m;
    for (; b; b >>= 1, a = mul(a, a, m))
        if (b & 1)
            res = mul(res, a, m);
    return res;
}
bool isprime(i64 n) {
    if (n < 2)
        return false;
    static constexpr int A[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    int s = __builtin_ctzll(n - 1);
    i64 d = (n - 1) >> s;
    for (auto a : A) {
        if (a == n)
            return true;
        i64 x = power(a, d, n);
        if (x == 1 || x == n - 1)
            continue;
        bool ok = false;
        for (int i = 0; i < s - 1; ++i) {
            x = mul(x, x, n);
            if (x == n - 1) {
                ok = true;
                break;
            }
        }
        if (!ok)
            return false;
    }
    return true;
}
std::vector<i64> factorize(i64 n) {
    std::vector<i64> p;
    std::function<void(i64)> f = [&](i64 n) {
        if (n <= 10000) {
            for (int i = 2; i * i <= n; ++i)
                for (; n % i == 0; n /= i)
                    p.push_back(i);
            if (n > 1)
                p.push_back(n);
            return;
        }
        if (isprime(n)) {
            p.push_back(n);
            return;
        }
        auto g = [&](i64 x) {
            return (mul(x, x, n) + 1) % n;
        };
        i64 x0 = 2;
        while (true) {
            i64 x = x0;
            i64 y = x0;
            i64 d = 1;
            i64 power = 1, lam = 0;
            i64 v = 1;
            while (d == 1) {
                y = g(y);
                ++lam;
                v = mul(v, std::abs(x - y), n);
                if (lam % 127 == 0) {
                    d = std::gcd(v, n);
                    v = 1;
                }
                if (power == lam) {
                    x = y;
                    power *= 2;
                    lam = 0;
                    d = std::gcd(v, n);
                    v = 1;
                }
            }
            if (d != n) {
                f(d);
                f(n / d);
                return;
            }
            ++x0;
        }
    };
    f(n);
    std::sort(p.begin(), p.end());
    return p;
}

09 - 平面几何

2023-07-17

长度过长，点击查看

template<class T>
struct Point {
    T x;
    T y;
    Point(T x_ = 0, T y_ = 0) : x(x_), y(y_) {}

    template<class U>
    operator Point<U>() {
        return Point<U>(U(x), U(y));
    }
    Point &operator+=(Point p) & {
        x += p.x;
        y += p.y;
        return *this;
    }
    Point &operator-=(Point p) & {
        x -= p.x;
        y -= p.y;
        return *this;
    }
    Point &operator*=(T v) & {
        x *= v;
        y *= v;
        return *this;
    }
    Point operator-() const {
        return Point(-x, -y);
    }
    friend Point operator+(Point a, Point b) {
        return a += b;
    }
    friend Point operator-(Point a, Point b) {
        return a -= b;
    }
    friend Point operator*(Point a, T b) {
        return a *= b;
    }
    friend Point operator*(T a, Point b) {
        return b *= a;
    }
    friend bool operator==(Point a, Point b) {
        return a.x == b.x && a.y == b.y;
    }
    friend std::istream &operator>>(std::istream &is, Point &p) {
        return is >> p.x >> p.y;
    }
    friend std::ostream &operator<<(std::ostream &os, Point p) {
        return os << "(" << p.x << ", " << p.y << ")";
    }
};

template<class T>
T dot(Point<T> a, Point<T> b) {
    return a.x * b.x + a.y * b.y;
}

template<class T>
T cross(Point<T> a, Point<T> b) {
    return a.x * b.y - a.y * b.x;
}

template<class T>
T square(Point<T> p) {
    return dot(p, p);
}

template<class T>
double length(Point<T> p) {
    return std::sqrt(double(square(p)));
}

long double length(Point<long double> p) {
    return std::sqrt(square(p));
}

template<class T>
struct Line {
    Point<T> a;
    Point<T> b;
    Line(Point<T> a_ = Point<T>(), Point<T> b_ = Point<T>()) : a(a_), b(b_) {}
};

template<class T>
Point<T> rotate(Point<T> a) {
    return Point(-a.y, a.x);
}

template<class T>
int sgn(Point<T> a) {
    return a.y > 0 || (a.y == 0 && a.x > 0) ? 1 : -1;
}

template<class T>
bool pointOnLineLeft(Point<T> p, Line<T> l) {
    return cross(l.b - l.a, p - l.a) > 0;
}

template<class T>
Point<T> lineIntersection(Line<T> l1, Line<T> l2) {
    return l1.a + (l1.b - l1.a) * (cross(l2.b - l2.a, l1.a - l2.a) / cross(l2.b - l2.a, l1.a - l1.b));
}

template<class T>
bool pointOnSegment(Point<T> p, Line<T> l) {
    return cross(p - l.a, l.b - l.a) == 0 && std::min(l.a.x, l.b.x) <= p.x && p.x <= std::max(l.a.x, l.b.x)
    && std::min(l.a.y, l.b.y) <= p.y && p.y <= std::max(l.a.y, l.b.y);
}

template<class T>
bool pointInPolygon(Point<T> a, std::vector<Point<T>> p) {
    int n = p.size();
    for (int i = 0; i < n; i++) {
        if (pointOnSegment(a, Line(p[i], p[(i + 1) % n]))) {
            return true;
        }
    }

    int t = 0;
    for (int i = 0; i < n; i++) {
        auto u = p[i];
        auto v = p[(i + 1) % n];
        if (u.x < a.x && v.x >= a.x && pointOnLineLeft(a, Line(v, u))) {
            t ^= 1;
        }
        if (u.x >= a.x && v.x < a.x && pointOnLineLeft(a, Line(u, v))) {
            t ^= 1;
        }
    }

    return t == 1;
}

// 0 : not intersect
// 1 : strictly intersect
// 2 : overlap
// 3 : intersect at endpoint
template<class T>
std::tuple<int, Point<T>, Point<T>> segmentIntersection(Line<T> l1, Line<T> l2) {
    if (std::max(l1.a.x, l1.b.x) < std::min(l2.a.x, l2.b.x)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::min(l1.a.x, l1.b.x) > std::max(l2.a.x, l2.b.x)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::max(l1.a.y, l1.b.y) < std::min(l2.a.y, l2.b.y)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::min(l1.a.y, l1.b.y) > std::max(l2.a.y, l2.b.y)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (cross(l1.b - l1.a, l2.b - l2.a) == 0) {
        if (cross(l1.b - l1.a, l2.a - l1.a) != 0) {
            return {0, Point<T>(), Point<T>()};
        } else {
            auto maxx1 = std::max(l1.a.x, l1.b.x);
            auto minx1 = std::min(l1.a.x, l1.b.x);
            auto maxy1 = std::max(l1.a.y, l1.b.y);
            auto miny1 = std::min(l1.a.y, l1.b.y);
            auto maxx2 = std::max(l2.a.x, l2.b.x);
            auto minx2 = std::min(l2.a.x, l2.b.x);
            auto maxy2 = std::max(l2.a.y, l2.b.y);
            auto miny2 = std::min(l2.a.y, l2.b.y);
            Point<T> p1(std::max(minx1, minx2), std::max(miny1, miny2));
            Point<T> p2(std::min(maxx1, maxx2), std::min(maxy1, maxy2));
            if (!pointOnSegment(p1, l1)) {
                std::swap(p1.y, p2.y);
            }
            if (p1 == p2) {
                return {3, p1, p2};
            } else {
                return {2, p1, p2};
            }
        }
    }
    auto cp1 = cross(l2.a - l1.a, l2.b - l1.a);
    auto cp2 = cross(l2.a - l1.b, l2.b - l1.b);
    auto cp3 = cross(l1.a - l2.a, l1.b - l2.a);
    auto cp4 = cross(l1.a - l2.b, l1.b - l2.b);

    if ((cp1 > 0 && cp2 > 0) || (cp1 < 0 && cp2 < 0) || (cp3 > 0 && cp4 > 0) || (cp3 < 0 && cp4 < 0)) {
        return {0, Point<T>(), Point<T>()};
    }

    Point p = lineIntersection(l1, l2);
    if (cp1 != 0 && cp2 != 0 && cp3 != 0 && cp4 != 0) {
        return {1, p, p};
    } else {
        return {3, p, p};
    }
}

template<class T>
bool segmentInPolygon(Line<T> l, std::vector<Point<T>> p) {
    int n = p.size();
    if (!pointInPolygon(l.a, p)) {
        return false;
    }
    if (!pointInPolygon(l.b, p)) {
        return false;
    }
    for (int i = 0; i < n; i++) {
        auto u = p[i];
        auto v = p[(i + 1) % n];
        auto w = p[(i + 2) % n];
        auto [t, p1, p2] = segmentIntersection(l, Line(u, v));

        if (t == 1) {
            return false;
        }
        if (t == 0) {
            continue;
        }
        if (t == 2) {
            if (pointOnSegment(v, l) && v != l.a && v != l.b) {
                if (cross(v - u, w - v) > 0) {
                    return false;
                }
            }
        } else {
            if (p1 != u && p1 != v) {
                if (pointOnLineLeft(l.a, Line(v, u))
                    || pointOnLineLeft(l.b, Line(v, u))) {
                    return false;
                }
            } else if (p1 == v) {
                if (l.a == v) {
                    if (pointOnLineLeft(u, l)) {
                        if (pointOnLineLeft(w, l)
                            && pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, l)
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                } else if (l.b == v) {
                    if (pointOnLineLeft(u, Line(l.b, l.a))) {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            && pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                } else {
                    if (pointOnLineLeft(u, l)) {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, l)
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                }
            }
        }
    }
    return true;
}

template<class T>
std::vector<Point<T>> hp(std::vector<Line<T>> lines) {
    std::sort(lines.begin(), lines.end(), [&](auto l1, auto l2) {
        auto d1 = l1.b - l1.a;
        auto d2 = l2.b - l2.a;

        if (sgn(d1) != sgn(d2)) {
            return sgn(d1) == 1;
        }

        return cross(d1, d2) > 0;
    });

    std::deque<Line<T>> ls;
    std::deque<Point<T>> ps;
    for (auto l : lines) {
        if (ls.empty()) {
            ls.push_back(l);
            continue;
        }

        while (!ps.empty() && !pointOnLineLeft(ps.back(), l)) {
            ps.pop_back();
            ls.pop_back();
        }

        while (!ps.empty() && !pointOnLineLeft(ps[0], l)) {
            ps.pop_front();
            ls.pop_front();
        }

        if (cross(l.b - l.a, ls.back().b - ls.back().a) == 0) {
            if (dot(l.b - l.a, ls.back().b - ls.back().a) > 0) {

                if (!pointOnLineLeft(ls.back().a, l)) {
                    assert(ls.size() == 1);
                    ls[0] = l;
                }
                continue;
            }
            return {};
        }

        ps.push_back(lineIntersection(ls.back(), l));
        ls.push_back(l);
    }

    while (!ps.empty() && !pointOnLineLeft(ps.back(), ls[0])) {
        ps.pop_back();
        ls.pop_back();
    }
    if (ls.size() <= 2) {
        return {};
    }
    ps.push_back(lineIntersection(ls[0], ls.back()));

    return std::vector(ps.begin(), ps.end());
}

10 - 静态凸包

2023-04-09

struct Point {
    i64 x;
    i64 y;
    Point(i64 x = 0, i64 y = 0) : x(x), y(y) {}
};

bool operator==(const Point &a, const Point &b) {
    return a.x == b.x && a.y == b.y;
}

Point operator+(const Point &a, const Point &b) {
    return Point(a.x + b.x, a.y + b.y);
}

Point operator-(const Point &a, const Point &b) {
    return Point(a.x - b.x, a.y - b.y);
}

i64 dot(const Point &a, const Point &b) {
    return a.x * b.x + a.y * b.y;
}

i64 cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}

void norm(std::vector<Point> &h) {
    int i = 0;
    for (int j = 0; j < int(h.size()); j++) {
        if (h[j].y < h[i].y || (h[j].y == h[i].y && h[j].x < h[i].x)) {
            i = j;
        }
    }
    std::rotate(h.begin(), h.begin() + i, h.end());
}

int sgn(const Point &a) {
    return a.y > 0 || (a.y == 0 && a.x > 0) ? 0 : 1;
}

std::vector<Point> getHull(std::vector<Point> p) {
    std::vector<Point> h, l;
    std::sort(p.begin(), p.end(), [&](auto a, auto b) {
        if (a.x != b.x) {
            return a.x < b.x;
        } else {
            return a.y < b.y;
        }
    });
    p.erase(std::unique(p.begin(), p.end()), p.end());
    if (p.size() <= 1) {
        return p;
    }

    for (auto a : p) {
        while (h.size() > 1 && cross(a - h.back(), a - h[h.size() - 2]) <= 0) {
            h.pop_back();
        }
        while (l.size() > 1 && cross(a - l.back(), a - l[l.size() - 2]) >= 0) {
            l.pop_back();
        }
        l.push_back(a);
        h.push_back(a);
    }

    l.pop_back();
    std::reverse(h.begin(), h.end());
    h.pop_back();
    l.insert(l.end(), h.begin(), h.end());
    return l;
}

11A - 多项式相关（Poly 旧版）

2023-02-06

长度过长，点击查看

std::vector<int> rev;
std::vector<Z> roots{0, 1};
void dft(std::vector<Z> &a) {
    int n = a.size();

    if (int(rev.size()) != n) {
        int k = __builtin_ctz(n) - 1;
        rev.resize(n);
        for (int i = 0; i < n; i++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << k;
        }
    }

    for (int i = 0; i < n; i++) {
        if (rev[i] < i) {
            std::swap(a[i], a[rev[i]]);
        }
    }
    if (int(roots.size()) < n) {
        int k = __builtin_ctz(roots.size());
        roots.resize(n);
        while ((1 << k) < n) {
            Z e = power(Z(3), (P - 1) >> (k + 1));
            for (int i = 1 << (k - 1); i < (1 << k); i++) {
                roots[2 * i] = roots[i];
                roots[2 * i + 1] = roots[i] * e;
            }
            k++;
        }
    }
    for (int k = 1; k < n; k *= 2) {
        for (int i = 0; i < n; i += 2 * k) {
            for (int j = 0; j < k; j++) {
                Z u = a[i + j];
                Z v = a[i + j + k] * roots[k + j];
                a[i + j] = u + v;
                a[i + j + k] = u - v;
            }
        }
    }
}
void idft(std::vector<Z> &a) {
    int n = a.size();
    std::reverse(a.begin() + 1, a.end());
    dft(a);
    Z inv = (1 - P) / n;
    for (int i = 0; i < n; i++) {
        a[i] *= inv;
    }
}
struct Poly {
    std::vector<Z> a;
    Poly() {}
    explicit Poly(int size, std::function<Z(int)> f = [](int) { return 0; }) : a(size) {
        for (int i = 0; i < size; i++) {
            a[i] = f(i);
        }
    }
    Poly(const std::vector<Z> &a) : a(a) {}
    Poly(const std::initializer_list<Z> &a) : a(a) {}
    int size() const {
        return a.size();
    }
    void resize(int n) {
        a.resize(n);
    }
    Z operator[](int idx) const {
        if (idx < size()) {
            return a[idx];
        } else {
            return 0;
        }
    }
    Z &operator[](int idx) {
        return a[idx];
    }
    Poly mulxk(int k) const {
        auto b = a;
        b.insert(b.begin(), k, 0);
        return Poly(b);
    }
    Poly modxk(int k) const {
        k = std::min(k, size());
        return Poly(std::vector<Z>(a.begin(), a.begin() + k));
    }
    Poly divxk(int k) const {
        if (size() <= k) {
            return Poly();
        }
        return Poly(std::vector<Z>(a.begin() + k, a.end()));
    }
    friend Poly operator+(const Poly &a, const Poly &b) {
        std::vector<Z> res(std::max(a.size(), b.size()));
        for (int i = 0; i < int(res.size()); i++) {
            res[i] = a[i] + b[i];
        }
        return Poly(res);
    }
    friend Poly operator-(const Poly &a, const Poly &b) {
        std::vector<Z> res(std::max(a.size(), b.size()));
        for (int i = 0; i < int(res.size()); i++) {
            res[i] = a[i] - b[i];
        }
        return Poly(res);
    }
    friend Poly operator-(const Poly &a) {
        std::vector<Z> res(a.size());
        for (int i = 0; i < int(res.size()); i++) {
            res[i] = -a[i];
        }
        return Poly(res);
    }
    friend Poly operator*(Poly a, Poly b) {
        if (a.size() == 0 || b.size() == 0) {
            return Poly();
        }
        if (a.size() < b.size()) {
            std::swap(a, b);
        }
        if (b.size() < 128) {
            Poly c(a.size() + b.size() - 1);
            for (int i = 0; i < a.size(); i++) {
                for (int j = 0; j < b.size(); j++) {
                    c[i + j] += a[i] * b[j];
                }
            }
            return c;
        }
        int sz = 1, tot = a.size() + b.size() - 1;
        while (sz < tot) {
            sz *= 2;
        }
        a.a.resize(sz);
        b.a.resize(sz);
        dft(a.a);
        dft(b.a);
        for (int i = 0; i < sz; ++i) {
            a.a[i] = a[i] * b[i];
        }
        idft(a.a);
        a.resize(tot);
        return a;
    }
    friend Poly operator*(Z a, Poly b) {
        for (int i = 0; i < int(b.size()); i++) {
            b[i] *= a;
        }
        return b;
    }
    friend Poly operator*(Poly a, Z b) {
        for (int i = 0; i < int(a.size()); i++) {
            a[i] *= b;
        }
        return a;
    }
    Poly &operator+=(Poly b) {
        return (*this) = (*this) + b;
    }
    Poly &operator-=(Poly b) {
        return (*this) = (*this) - b;
    }
    Poly &operator*=(Poly b) {
        return (*this) = (*this) * b;
    }
    Poly &operator*=(Z b) {
        return (*this) = (*this) * b;
    }
    Poly deriv() const {
        if (a.empty()) {
            return Poly();
        }
        std::vector<Z> res(size() - 1);
        for (int i = 0; i < size() - 1; ++i) {
            res[i] = (i + 1) * a[i + 1];
        }
        return Poly(res);
    }
    Poly integr() const {
        std::vector<Z> res(size() + 1);
        for (int i = 0; i < size(); ++i) {
            res[i + 1] = a[i] / (i + 1);
        }
        return Poly(res);
    }
    Poly inv(int m) const {
        Poly x{a[0].inv()};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{2} - modxk(k) * x)).modxk(k);
        }
        return x.modxk(m);
    }
    Poly log(int m) const {
        return (deriv() * inv(m)).integr().modxk(m);
    }
    Poly exp(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{1} - x.log(k) + modxk(k))).modxk(k);
        }
        return x.modxk(m);
    }
    Poly pow(int k, int m) const {
        int i = 0;
        while (i < size() && a[i].val() == 0) {
            i++;
        }
        if (i == size() || 1LL * i * k >= m) {
            return Poly(std::vector<Z>(m));
        }
        Z v = a[i];
        auto f = divxk(i) * v.inv();
        return (f.log(m - i * k) * k).exp(m - i * k).mulxk(i * k) * power(v, k);
    }
    Poly sqrt(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x + (modxk(k) * x.inv(k)).modxk(k)) * ((P + 1) / 2);
        }
        return x.modxk(m);
    }
    Poly mulT(Poly b) const {
        if (b.size() == 0) {
            return Poly();
        }
        int n = b.size();
        std::reverse(b.a.begin(), b.a.end());
        return ((*this) * b).divxk(n - 1);
    }
    std::vector<Z> eval(std::vector<Z> x) const {
        if (size() == 0) {
            return std::vector<Z>(x.size(), 0);
        }
        const int n = std::max(int(x.size()), size());
        std::vector<Poly> q(4 * n);
        std::vector<Z> ans(x.size());
        x.resize(n);
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                q[p] = Poly{1, -x[l]};
            } else {
                int m = (l + r) / 2;
                build(2 * p, l, m);
                build(2 * p + 1, m, r);
                q[p] = q[2 * p] * q[2 * p + 1];
            }
        };
        build(1, 0, n);
        std::function<void(int, int, int, const Poly &)> work = [&](int p, int l, int r, const Poly &num) {
            if (r - l == 1) {
                if (l < int(ans.size())) {
                    ans[l] = num[0];
                }
            } else {
                int m = (l + r) / 2;
                work(2 * p, l, m, num.mulT(q[2 * p + 1]).modxk(m - l));
                work(2 * p + 1, m, r, num.mulT(q[2 * p]).modxk(r - m));
            }
        };
        work(1, 0, n, mulT(q[1].inv(n)));
        return ans;
    }
};

11B - 多项式相关（Poly+MInt & MLong 新版）

2023-09-20

长度过长，点击查看

std::vector<int> rev;
template<int P>
std::vector<MInt<P>> roots{0, 1};

template<int P>
constexpr MInt<P> findPrimitiveRoot() {
    MInt<P> i = 2;
    int k = __builtin_ctz(P - 1);
    while (true) {
        if (power(i, (P - 1) / 2) != 1) {
            break;
        }
        i += 1;
    }
    return power(i, (P - 1) >> k);
}

template<int P>
constexpr MInt<P> primitiveRoot = findPrimitiveRoot<P>();

template<>
constexpr MInt<998244353> primitiveRoot<998244353> {31};

template<int P>
constexpr void dft(std::vector<MInt<P>> &a) {
    int n = a.size();

    if (int(rev.size()) != n) {
        int k = __builtin_ctz(n) - 1;
        rev.resize(n);
        for (int i = 0; i < n; i++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << k;
        }
    }

    for (int i = 0; i < n; i++) {
        if (rev[i] < i) {
            std::swap(a[i], a[rev[i]]);
        }
    }
    if (roots<P>.size() < n) {
        int k = __builtin_ctz(roots<P>.size());
        roots<P>.resize(n);
        while ((1 << k) < n) {
            auto e = power(primitiveRoot<P>, 1 << (__builtin_ctz(P - 1) - k - 1));
            for (int i = 1 << (k - 1); i < (1 << k); i++) {
                roots<P>[2 * i] = roots<P>[i];
                roots<P>[2 * i + 1] = roots<P>[i] * e;
            }
            k++;
        }
    }
    for (int k = 1; k < n; k *= 2) {
        for (int i = 0; i < n; i += 2 * k) {
            for (int j = 0; j < k; j++) {
                MInt<P> u = a[i + j];
                MInt<P> v = a[i + j + k] * roots<P>[k + j];
                a[i + j] = u + v;
                a[i + j + k] = u - v;
            }
        }
    }
}

template<int P>
constexpr void idft(std::vector<MInt<P>> &a) {
    int n = a.size();
    std::reverse(a.begin() + 1, a.end());
    dft(a);
    MInt<P> inv = (1 - P) / n;
    for (int i = 0; i < n; i++) {
        a[i] *= inv;
    }
}

template<int P = 998244353>
struct Poly : public std::vector<MInt<P>> {
    using Value = MInt<P>;

    Poly() : std::vector<Value>() {}
    explicit constexpr Poly(int n) : std::vector<Value>(n) {}

    explicit constexpr Poly(const std::vector<Value> &a) : std::vector<Value>(a) {}
    constexpr Poly(const std::initializer_list<Value> &a) : std::vector<Value>(a) {}

    template<class InputIt, class = std::_RequireInputIter<InputIt>>
    explicit constexpr Poly(InputIt first, InputIt last) : std::vector<Value>(first, last) {}

    template<class F>
    explicit constexpr Poly(int n, F f) : std::vector<Value>(n) {
        for (int i = 0; i < n; i++) {
            (*this)[i] = f(i);
        }
    }

    constexpr Poly shift(int k) const {
        if (k >= 0) {
            auto b = *this;
            b.insert(b.begin(), k, 0);
            return b;
        } else if (this->size() <= -k) {
            return Poly();
        } else {
            return Poly(this->begin() + (-k), this->end());
        }
    }
    constexpr Poly trunc(int k) const {
        Poly f = *this;
        f.resize(k);
        return f;
    }
    constexpr friend Poly operator+(const Poly &a, const Poly &b) {
        Poly res(std::max(a.size(), b.size()));
        for (int i = 0; i < a.size(); i++) {
            res[i] += a[i];
        }
        for (int i = 0; i < b.size(); i++) {
            res[i] += b[i];
        }
        return res;
    }
    constexpr friend Poly operator-(const Poly &a, const Poly &b) {
        Poly res(std::max(a.size(), b.size()));
        for (int i = 0; i < a.size(); i++) {
            res[i] += a[i];
        }
        for (int i = 0; i < b.size(); i++) {
            res[i] -= b[i];
        }
        return res;
    }
    constexpr friend Poly operator-(const Poly &a) {
        std::vector<Value> res(a.size());
        for (int i = 0; i < int(res.size()); i++) {
            res[i] = -a[i];
        }
        return Poly(res);
    }
    constexpr friend Poly operator*(Poly a, Poly b) {
        if (a.size() == 0 || b.size() == 0) {
            return Poly();
        }
        if (a.size() < b.size()) {
            std::swap(a, b);
        }
        int n = 1, tot = a.size() + b.size() - 1;
        while (n < tot) {
            n *= 2;
        }
        if (((P - 1) & (n - 1)) != 0 || b.size() < 128) {
            Poly c(a.size() + b.size() - 1);
            for (int i = 0; i < a.size(); i++) {
                for (int j = 0; j < b.size(); j++) {
                    c[i + j] += a[i] * b[j];
                }
            }
            return c;
        }
        a.resize(n);
        b.resize(n);
        dft(a);
        dft(b);
        for (int i = 0; i < n; ++i) {
            a[i] *= b[i];
        }
        idft(a);
        a.resize(tot);
        return a;
    }
    constexpr friend Poly operator*(Value a, Poly b) {
        for (int i = 0; i < int(b.size()); i++) {
            b[i] *= a;
        }
        return b;
    }
    constexpr friend Poly operator*(Poly a, Value b) {
        for (int i = 0; i < int(a.size()); i++) {
            a[i] *= b;
        }
        return a;
    }
    constexpr friend Poly operator/(Poly a, Value b) {
        for (int i = 0; i < int(a.size()); i++) {
            a[i] /= b;
        }
        return a;
    }
    constexpr Poly &operator+=(Poly b) {
        return (*this) = (*this) + b;
    }
    constexpr Poly &operator-=(Poly b) {
        return (*this) = (*this) - b;
    }
    constexpr Poly &operator*=(Poly b) {
        return (*this) = (*this) * b;
    }
    constexpr Poly &operator*=(Value b) {
        return (*this) = (*this) * b;
    }
    constexpr Poly &operator/=(Value b) {
        return (*this) = (*this) / b;
    }
    constexpr Poly deriv() const {
        if (this->empty()) {
            return Poly();
        }
        Poly res(this->size() - 1);
        for (int i = 0; i < this->size() - 1; ++i) {
            res[i] = (i + 1) * (*this)[i + 1];
        }
        return res;
    }
    constexpr Poly integr() const {
        Poly res(this->size() + 1);
        for (int i = 0; i < this->size(); ++i) {
            res[i + 1] = (*this)[i] / (i + 1);
        }
        return res;
    }
    constexpr Poly inv(int m) const {
        Poly x{(*this)[0].inv()};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{2} - trunc(k) * x)).trunc(k);
        }
        return x.trunc(m);
    }
    constexpr Poly log(int m) const {
        return (deriv() * inv(m)).integr().trunc(m);
    }
    constexpr Poly exp(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{1} - x.log(k) + trunc(k))).trunc(k);
        }
        return x.trunc(m);
    }
    constexpr Poly pow(int k, int m) const {
        int i = 0;
        while (i < this->size() && (*this)[i] == 0) {
            i++;
        }
        if (i == this->size() || 1LL * i * k >= m) {
            return Poly(m);
        }
        Value v = (*this)[i];
        auto f = shift(-i) * v.inv();
        return (f.log(m - i * k) * k).exp(m - i * k).shift(i * k) * power(v, k);
    }
    constexpr Poly sqrt(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x + (trunc(k) * x.inv(k)).trunc(k)) * CInv<2, P>;
        }
        return x.trunc(m);
    }
    constexpr Poly mulT(Poly b) const {
        if (b.size() == 0) {
            return Poly();
        }
        int n = b.size();
        std::reverse(b.begin(), b.end());
        return ((*this) * b).shift(-(n - 1));
    }
    constexpr std::vector<Value> eval(std::vector<Value> x) const {
        if (this->size() == 0) {
            return std::vector<Value>(x.size(), 0);
        }
        const int n = std::max(x.size(), this->size());
        std::vector<Poly> q(4 * n);
        std::vector<Value> ans(x.size());
        x.resize(n);
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                q[p] = Poly{1, -x[l]};
            } else {
                int m = (l + r) / 2;
                build(2 * p, l, m);
                build(2 * p + 1, m, r);
                q[p] = q[2 * p] * q[2 * p + 1];
            }
        };
        build(1, 0, n);
        std::function<void(int, int, int, const Poly &)> work = [&](int p, int l, int r, const Poly &num) {
            if (r - l == 1) {
                if (l < int(ans.size())) {
                    ans[l] = num[0];
                }
            } else {
                int m = (l + r) / 2;
                work(2 * p, l, m, num.mulT(q[2 * p + 1]).resize(m - l));
                work(2 * p + 1, m, r, num.mulT(q[2 * p]).resize(r - m));
            }
        };
        work(1, 0, n, mulT(q[1].inv(n)));
        return ans;
    }
};

template<int P = 998244353>
Poly<P> berlekampMassey(const Poly<P> &s) {
    Poly<P> c;
    Poly<P> oldC;
    int f = -1;
    for (int i = 0; i < s.size(); i++) {
        auto delta = s[i];
        for (int j = 1; j <= c.size(); j++) {
            delta -= c[j - 1] * s[i - j];
        }
        if (delta == 0) {
            continue;
        }
        if (f == -1) {
            c.resize(i + 1);
            f = i;
        } else {
            auto d = oldC;
            d *= -1;
            d.insert(d.begin(), 1);
            MInt<P> df1 = 0;
            for (int j = 1; j <= d.size(); j++) {
                df1 += d[j - 1] * s[f + 1 - j];
            }
            assert(df1 != 0);
            auto coef = delta / df1;
            d *= coef;
            Poly<P> zeros(i - f - 1);
            zeros.insert(zeros.end(), d.begin(), d.end());
            d = zeros;
            auto temp = c;
            c += d;
            if (i - temp.size() > f - oldC.size()) {
                oldC = temp;
                f = i;
            }
        }
    }
    c *= -1;
    c.insert(c.begin(), 1);
    return c;
}


template<int P = 998244353>
MInt<P> linearRecurrence(Poly<P> p, Poly<P> q, i64 n) {
    int m = q.size() - 1;
    while (n > 0) {
        auto newq = q;
        for (int i = 1; i <= m; i += 2) {
            newq[i] *= -1;
        }
        auto newp = p * newq;
        newq = q * newq;
        for (int i = 0; i < m; i++) {
            p[i] = newp[i * 2 + n % 2];
        }
        for (int i = 0; i <= m; i++) {
            q[i] = newq[i * 2];
        }
        n /= 2;
    }
    return p[0] / q[0];
}

struct Comb {
    int n;
    std::vector<Z> _fac;
    std::vector<Z> _invfac;
    std::vector<Z> _inv;

    Comb() : n{0}, _fac{1}, _invfac{1}, _inv{0} {}
    Comb(int n) : Comb() {
        init(n);
    }

    void init(int m) {
        m = std::min(m, Z::getMod() - 1);
        if (m <= n) return;
        _fac.resize(m + 1);
        _invfac.resize(m + 1);
        _inv.resize(m + 1);

        for (int i = n + 1; i <= m; i++) {
            _fac[i] = _fac[i - 1] * i;
        }
        _invfac[m] = _fac[m].inv();
        for (int i = m; i > n; i--) {
            _invfac[i - 1] = _invfac[i] * i;
            _inv[i] = _invfac[i] * _fac[i - 1];
        }
        n = m;
    }

    Z fac(int m) {
        if (m > n) init(2 * m);
        return _fac[m];
    }
    Z invfac(int m) {
        if (m > n) init(2 * m);
        return _invfac[m];
    }
    Z inv(int m) {
        if (m > n) init(2 * m);
        return _inv[m];
    }
    Z binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fac(n) * invfac(m) * invfac(n - m);
    }
} comb;

Poly<P> get(int n, int m) {
    if (m == 0) {
        return Poly(n + 1);
    }
    if (m % 2 == 1) {
        auto f = get(n, m - 1);
        Z p = 1;
        for (int i = 0; i <= n; i++) {
            f[n - i] += comb.binom(n, i) * p;
            p *= m;
        }
        return f;
    }
    auto f = get(n, m / 2);
    auto fm = f;
    for (int i = 0; i <= n; i++) {
        fm[i] *= comb.fac(i);
    }
    Poly pw(n + 1);
    pw[0] = 1;
    for (int i = 1; i <= n; i++) {
        pw[i] = pw[i - 1] * (m / 2);
    }
    for (int i = 0; i <= n; i++) {
        pw[i] *= comb.invfac(i);
    }
    fm = fm.mulT(pw);
    for (int i = 0; i <= n; i++) {
        fm[i] *= comb.invfac(i);
    }
    return f + fm;
}

四、数据结构

01A - 树状数组（Fenwick 旧版）

2023-08-11

template <typename T>
struct Fenwick {
    int n;
    std::vector<T> a;

    Fenwick(int n = 0) {
        init(n);
    }

    void init(int n) {
        this->n = n;
        a.assign(n, T());
    }

    void add(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i - 1] += v;
        }
    }

    T sum(int x) {
        auto ans = T();
        for (int i = x; i > 0; i -= i & -i) {
            ans += a[i - 1];
        }
        return ans;
    }

    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }

    int kth(T k) {
        int x = 0;
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && k >= a[x + i - 1]) {
                x += i;
                k -= a[x - 1];
            }
        }
        return x;
    }
};

01B - 树状数组（Fenwick 新版）

2023-12-28

template <typename T>
struct Fenwick {
    int n;
    std::vector<T> a;

    Fenwick(int n_ = 0) {
        init(n_);
    }

    void init(int n_) {
        n = n_;
        a.assign(n, T{});
    }

    void add(int x, const T &v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i - 1] = a[i - 1] + v;
        }
    }

    T sum(int x) {
        T ans{};
        for (int i = x; i > 0; i -= i & -i) {
            ans = ans + a[i - 1];
        }
        return ans;
    }

    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }

    int select(const T &k) {
        int x = 0;
        T cur{};
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && cur + a[x + i - 1] <= k) {
                x += i;
                cur = cur + a[x - 1];
            }
        }
        return x;
    }
};

02 - 并查集（DSU）

2023-08-04

struct DSU {
    std::vector<int> f, siz;

    DSU() {}
    DSU(int n) {
        init(n);
    }

    void init(int n) {
        f.resize(n);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }

    int find(int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    }

    bool same(int x, int y) {
        return find(x) == find(y);
    }

    bool merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }

    int size(int x) {
        return siz[find(x)];
    }
};

03A - 线段树（SegmentTree 基础区间加乘）

2023-10-18

struct SegmentTree {
    int n;
    std::vector<int> tag, sum;
    SegmentTree(int n_) : n(n_), tag(4 * n, 1), sum(4 * n) {}

    void pull(int p) {
        sum[p] = (sum[2 * p] + sum[2 * p + 1]) % P;
    }

    void mul(int p, int v) {
        tag[p] = 1LL * tag[p] * v % P;
        sum[p] = 1LL * sum[p] * v % P;
    }

    void push(int p) {
        mul(2 * p, tag[p]);
        mul(2 * p + 1, tag[p]);
        tag[p] = 1;
    }

    int query(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return 0;
        }
        if (l >= x && r <= y) {
            return sum[p];
        }
        int m = (l + r) / 2;
        push(p);
        return (query(2 * p, l, m, x, y) + query(2 * p + 1, m, r, x, y)) % P;
    }

    int query(int x, int y) {
        return query(1, 0, n, x, y);
    }

    void rangeMul(int p, int l, int r, int x, int y, int v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            return mul(p, v);
        }
        int m = (l + r) / 2;
        push(p);
        rangeMul(2 * p, l, m, x, y, v);
        rangeMul(2 * p + 1, m, r, x, y, v);
        pull(p);
    }

    void rangeMul(int x, int y, int v) {
        rangeMul(1, 0, n, x, y, v);
    }

    void add(int p, int l, int r, int x, int v) {
        if (r - l == 1) {
            sum[p] = (sum[p] + v) % P;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            add(2 * p, l, m, x, v);
        } else {
            add(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }

    void add(int x, int v) {
        add(1, 0, n, x, v);
    }
};

03B - 线段树（SegmentTree+Info 查找前驱后继）

2023-08-11

template<class Info>
struct SegmentTree {
    int n;
    std::vector<Info> info;
    SegmentTree() : n(0) {}
    SegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template<class T>
    SegmentTree(std::vector<T> init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template<class T>
    void init(std::vector<T> init_) {
        n = init_.size();
        info.assign(4 << std::__lg(n), Info());
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init_[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    template<class F>
    int findFirst(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        int res = findFirst(2 * p, l, m, x, y, pred);
        if (res == -1) {
            res = findFirst(2 * p + 1, m, r, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findFirst(int l, int r, F pred) {
        return findFirst(1, 0, n, l, r, pred);
    }
    template<class F>
    int findLast(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        int res = findLast(2 * p + 1, m, r, x, y, pred);
        if (res == -1) {
            res = findLast(2 * p, l, m, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findLast(int l, int r, F pred) {
        return findLast(1, 0, n, l, r, pred);
    }
};
struct Info {
    int cnt = 0;
    i64 sum = 0;
    i64 ans = 0;
};
Info operator+(Info a, Info b) {
    Info c;
    c.cnt = a.cnt + b.cnt;
    c.sum = a.sum + b.sum;
    c.ans = a.ans + b.ans + a.cnt * b.sum - a.sum * b.cnt;
    return c;
}

03C - 线段树（SegmentTree+Info+Merge 区间合并）

2022-04-23

template<class Info>
struct SegmentTree {
    int n;
    std::vector<Info> info;
    SegmentTree() : n(0) {}
    SegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template<class T>
    SegmentTree(std::vector<T> init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template<class T>
    void init(std::vector<T> init_) {
        n = init_.size();
        info.assign(4 << std::__lg(n), Info());
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init_[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    template<class F>
    int findFirst(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        int res = findFirst(2 * p, l, m, x, y, pred);
        if (res == -1) {
            res = findFirst(2 * p + 1, m, r, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findFirst(int l, int r, F pred) {
        return findFirst(1, 0, n, l, r, pred);
    }
    template<class F>
    int findLast(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        int res = findLast(2 * p + 1, m, r, x, y, pred);
        if (res == -1) {
            res = findLast(2 * p, l, m, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findLast(int l, int r, F pred) {
        return findLast(1, 0, n, l, r, pred);
    }
};

struct Info {
    int x = 0;
    int cnt = 0;
};

Info operator+(Info a, Info b) {
    if (a.x == b.x) {
        return {a.x, a.cnt + b.cnt};
    } else if (a.cnt > b.cnt) {
        return {a.x, a.cnt - b.cnt};
    } else {
        return {b.x, b.cnt - a.cnt};
    }
}

04A - 懒标记线段树（LazySegmentTree 基础区间修改）

2023-07-17

长度过长，点击查看

template<class Info, class Tag>
struct LazySegmentTree {
    const int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree(int n) : n(n), info(4 << std::__lg(n)), tag(4 << std::__lg(n)) {}
    LazySegmentTree(std::vector<Info> init) : LazySegmentTree(init.size()) {
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    void half(int p, int l, int r) {
        if (info[p].act == 0) {
            return;
        }
        if ((info[p].min + 1) / 2 == (info[p].max + 1) / 2) {
            apply(p, {-(info[p].min + 1) / 2});
            return;
        }
        int m = (l + r) / 2;
        push(p);
        half(2 * p, l, m);
        half(2 * p + 1, m, r);
        pull(p);
    }
    void half() {
        half(1, 0, n);
    }
};

constexpr i64 inf = 1E18;

struct Tag {
    i64 add = 0;

    void apply(Tag t) {
        add += t.add;
    }
};

struct Info {
    i64 min = inf;
    i64 max = -inf;
    i64 sum = 0;
    i64 act = 0;

    void apply(Tag t) {
        min += t.add;
        max += t.add;
        sum += act * t.add;
    }
};

Info operator+(Info a, Info b) {
    Info c;
    c.min = std::min(a.min, b.min);
    c.max = std::max(a.max, b.max);
    c.sum = a.sum + b.sum;
    c.act = a.act + b.act;
    return c;
}

04B - 懒标记线段树（LazySegmentTree 查找前驱后继）

2023-07-17

长度过长，点击查看

template<class Info, class Tag>
struct LazySegmentTree {
    int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree() : n(0) {}
    LazySegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template<class T>
    LazySegmentTree(std::vector<T> init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template<class T>
    void init(std::vector<T> init_) {
        n = init_.size();
        info.assign(4 << std::__lg(n), Info());
        tag.assign(4 << std::__lg(n), Tag());
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init_[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    template<class F>
    int findFirst(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        push(p);
        int res = findFirst(2 * p, l, m, x, y, pred);
        if (res == -1) {
            res = findFirst(2 * p + 1, m, r, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findFirst(int l, int r, F pred) {
        return findFirst(1, 0, n, l, r, pred);
    }
    template<class F>
    int findLast(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        push(p);
        int res = findLast(2 * p + 1, m, r, x, y, pred);
        if (res == -1) {
            res = findLast(2 * p, l, m, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findLast(int l, int r, F pred) {
        return findLast(1, 0, n, l, r, pred);
    }
};

struct Tag {
    i64 a = 0, b = 0;
    void apply(Tag t) {
        a = std::min(a, b + t.a);
        b += t.b;
    }
};

int k;

struct Info {
    i64 x = 0;
    void apply(Tag t) {
        x += t.a;
        if (x < 0) {
            x = (x % k + k) % k;
        }
        x += t.b - t.a;
    }
};
Info operator+(Info a, Info b) {
    return {a.x + b.x};
}

04C - 懒标记线段树（LazySegmentTree 二分修改）

2023-03-03

长度过长，点击查看

constexpr int inf = 1E9 + 1;
template<class Info, class Tag>
struct LazySegmentTree {
    const int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree(int n) : n(n), info(4 << std::__lg(n)), tag(4 << std::__lg(n)) {}
    LazySegmentTree(std::vector<Info> init) : LazySegmentTree(init.size()) {
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    void maintainL(int p, int l, int r, int pre) {
        if (info[p].difl > 0 && info[p].maxlowl < pre) {
            return;
        }
        if (r - l == 1) {
            info[p].max = info[p].maxlowl;
            info[p].maxl = info[p].maxr = l;
            info[p].maxlowl = info[p].maxlowr = -inf;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        maintainL(2 * p, l, m, pre);
        pre = std::max(pre, info[2 * p].max);
        maintainL(2 * p + 1, m, r, pre);
        pull(p);
    }
    void maintainL() {
        maintainL(1, 0, n, -1);
    }
    void maintainR(int p, int l, int r, int suf) {
        if (info[p].difr > 0 && info[p].maxlowr < suf) {
            return;
        }
        if (r - l == 1) {
            info[p].max = info[p].maxlowl;
            info[p].maxl = info[p].maxr = l;
            info[p].maxlowl = info[p].maxlowr = -inf;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        maintainR(2 * p + 1, m, r, suf);
        suf = std::max(suf, info[2 * p + 1].max);
        maintainR(2 * p, l, m, suf);
        pull(p);
    }
    void maintainR() {
        maintainR(1, 0, n, -1);
    }
};

struct Tag {
    int add = 0;

    void apply(Tag t) & {
        add += t.add;
    }
};

struct Info {
    int max = -1;
    int maxl = -1;
    int maxr = -1;
    int difl = inf;
    int difr = inf;
    int maxlowl = -inf;
    int maxlowr = -inf;

    void apply(Tag t) & {
        if (max != -1) {
            max += t.add;
        }
        difl += t.add;
        difr += t.add;
    }
};

Info operator+(Info a, Info b) {
    Info c;
    if (a.max > b.max) {
        c.max = a.max;
        c.maxl = a.maxl;
        c.maxr = a.maxr;
    } else if (a.max < b.max) {
        c.max = b.max;
        c.maxl = b.maxl;
        c.maxr = b.maxr;
    } else {
        c.max = a.max;
        c.maxl = a.maxl;
        c.maxr = b.maxr;
    }

    c.difl = std::min(a.difl, b.difl);
    c.difr = std::min(a.difr, b.difr);
    if (a.max != -1) {
        c.difl = std::min(c.difl, a.max - b.maxlowl);
    }
    if (b.max != -1) {
        c.difr = std::min(c.difr, b.max - a.maxlowr);
    }

    if (a.max == -1) {
        c.maxlowl = std::max(a.maxlowl, b.maxlowl);
    } else {
        c.maxlowl = a.maxlowl;
    }
    if (b.max == -1) {
        c.maxlowr = std::max(a.maxlowr, b.maxlowr);
    } else {
        c.maxlowr = b.maxlowr;
    }
    return c;
}

05A - 取模类（MLong & MInt）

2022-06-12

constexpr int P = 998244353;
using i64 = long long;
// assume -P <= x < 2P
int norm(int x) {
    if (x < 0) {
        x += P;
    }
    if (x >= P) {
        x -= P;
    }
    return x;
}
template<class T>
T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
struct Z {
    int x;
    Z(int x = 0) : x(norm(x)) {}
    Z(i64 x) : x(norm(x % P)) {}
    int val() const {
        return x;
    }
    Z operator-() const {
        return Z(norm(P - x));
    }
    Z inv() const {
        assert(x != 0);
        return power(*this, P - 2);
    }
    Z &operator*=(const Z &rhs) {
        x = i64(x) * rhs.x % P;
        return *this;
    }
    Z &operator+=(const Z &rhs) {
        x = norm(x + rhs.x);
        return *this;
    }
    Z &operator-=(const Z &rhs) {
        x = norm(x - rhs.x);
        return *this;
    }
    Z &operator/=(const Z &rhs) {
        return *this *= rhs.inv();
    }
    friend Z operator*(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res *= rhs;
        return res;
    }
    friend Z operator+(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res += rhs;
        return res;
    }
    friend Z operator-(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res -= rhs;
        return res;
    }
    friend Z operator/(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Z &a) {
        i64 v;
        is >> v;
        a = Z(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Z &a) {
        return os << a.val();
    }
};

05B - 取模类（MLong & MInt 新版）

2023-08-14

根据输入内容动态修改 MOD 的方法：Z::setMod(p); 。

长度过长，点击查看

template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

constexpr i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}
template<i64 P>
struct MLong {
    i64 x;
    constexpr MLong() : x{} {}
    constexpr MLong(i64 x) : x{norm(x % getMod())} {}

    static i64 Mod;
    constexpr static i64 getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(i64 Mod_) {
        Mod = Mod_;
    }
    constexpr i64 norm(i64 x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr i64 val() const {
        return x;
    }
    explicit constexpr operator i64() const {
        return x;
    }
    constexpr MLong operator-() const {
        MLong res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MLong inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MLong &operator*=(MLong rhs) & {
        x = mul(x, rhs.x, getMod());
        return *this;
    }
    constexpr MLong &operator+=(MLong rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MLong &operator-=(MLong rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MLong &operator/=(MLong rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MLong operator*(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MLong operator+(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MLong operator-(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MLong operator/(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MLong &a) {
        i64 v;
        is >> v;
        a = MLong(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MLong &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MLong lhs, MLong rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MLong lhs, MLong rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
i64 MLong<0LL>::Mod = i64(1E18) + 9;

template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}

    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
int MInt<0>::Mod = 998244353;

template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 1000000007;
using Z = MInt<P>;

06 - 状压RMQ（RMQ）

2023-03-02

template<class T,
    class Cmp = std::less<T>>
struct RMQ {
    const Cmp cmp = Cmp();
    static constexpr unsigned B = 64;
    using u64 = unsigned long long;
    int n;
    std::vector<std::vector<T>> a;
    std::vector<T> pre, suf, ini;
    std::vector<u64> stk;
    RMQ() {}
    RMQ(const std::vector<T> &v) {
        init(v);
    }
    void init(const std::vector<T> &v) {
        n = v.size();
        pre = suf = ini = v;
        stk.resize(n);
        if (!n) {
            return;
        }
        const int M = (n - 1) / B + 1;
        const int lg = std::__lg(M);
        a.assign(lg + 1, std::vector<T>(M));
        for (int i = 0; i < M; i++) {
            a[0][i] = v[i * B];
            for (int j = 1; j < B && i * B + j < n; j++) {
                a[0][i] = std::min(a[0][i], v[i * B + j], cmp);
            }
        }
        for (int i = 1; i < n; i++) {
            if (i % B) {
                pre[i] = std::min(pre[i], pre[i - 1], cmp);
            }
        }
        for (int i = n - 2; i >= 0; i--) {
            if (i % B != B - 1) {
                suf[i] = std::min(suf[i], suf[i + 1], cmp);
            }
        }
        for (int j = 0; j < lg; j++) {
            for (int i = 0; i + (2 << j) <= M; i++) {
                a[j + 1][i] = std::min(a[j][i], a[j][i + (1 << j)], cmp);
            }
        }
        for (int i = 0; i < M; i++) {
            const int l = i * B;
            const int r = std::min(1U * n, l + B);
            u64 s = 0;
            for (int j = l; j < r; j++) {
                while (s && cmp(v[j], v[std::__lg(s) + l])) {
                    s ^= 1ULL << std::__lg(s);
                }
                s |= 1ULL << (j - l);
                stk[j] = s;
            }
        }
    }
    T operator()(int l, int r) {
        if (l / B != (r - 1) / B) {
            T ans = std::min(suf[l], pre[r - 1], cmp);
            l = l / B + 1;
            r = r / B;
            if (l < r) {
                int k = std::__lg(r - l);
                ans = std::min({ans, a[k][l], a[k][r - (1 << k)]}, cmp);
            }
            return ans;
        } else {
            int x = B * (l / B);
            return ini[__builtin_ctzll(stk[r - 1] >> (l - x)) + l];
        }
    }
};

07 - Splay

2023-02-15

struct Node {
    Node *l = nullptr;
    Node *r = nullptr;
    int cnt = 0;
    i64 sum = 0;
};

Node *add(Node *t, int l, int r, int p, int v) {
    Node *x = new Node;
    if (t) {
        *x = *t;
    }
    x->cnt += 1;
    x->sum += v;
    if (r - l == 1) {
        return x;
    }
    int m = (l + r) / 2;
    if (p < m) {
        x->l = add(x->l, l, m, p, v);
    } else {
        x->r = add(x->r, m, r, p, v);
    }
    return x;
}

int find(Node *tl, Node *tr, int l, int r, int x) {
    if (r <= x) {
        return -1;
    }
    if (l >= x) {
        int cnt = (tr ? tr->cnt : 0) - (tl ? tl->cnt : 0);
        if (cnt == 0) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
    }
    int m = (l + r) / 2;
    int res = find(tl ? tl->l : tl, tr ? tr->l : tr, l, m, x);
    if (res == -1) {
        res = find(tl ? tl->r : tl, tr ? tr->r : tr, m, r, x);
    }
    return res;
}

std::pair<int, i64> get(Node *t, int l, int r, int x, int y) {
    if (l >= y || r <= x || !t) {
        return {0, 0LL};
    }
    if (l >= x && r <= y) {
        return {t->cnt, t->sum};
    }
    int m = (l + r) / 2;
    auto [cl, sl] = get(t->l, l, m, x, y);
    auto [cr, sr] = get(t->r, m, r, x, y);
    return {cl + cr, sl + sr};
}

struct Tree {
    int add = 0;
    int val = 0;
    int id = 0;
    Tree *ch[2] = {};
    Tree *p = nullptr;
};

int pos(Tree *t) {
    return t->p->ch[1] == t;
}

void add(Tree *t, int v) {
    t->val += v;
    t->add += v;
}

void push(Tree *t) {
    if (t->ch[0]) {
        add(t->ch[0], t->add);
    }
    if (t->ch[1]) {
        add(t->ch[1], t->add);
    }
    t->add = 0;
}

void rotate(Tree *t) {
    Tree *q = t->p;
    int x = !pos(t);
    q->ch[!x] = t->ch[x];
    if (t->ch[x]) t->ch[x]->p = q;
    t->p = q->p;
    if (q->p) q->p->ch[pos(q)] = t;
    t->ch[x] = q;
    q->p = t;
}

void splay(Tree *t) {
    std::vector<Tree *> s;
    for (Tree *i = t; i->p; i = i->p) s.push_back(i->p);
    while (!s.empty()) {
        push(s.back());
        s.pop_back();
    }
    push(t);
    while (t->p) {
        if (t->p->p) {
            if (pos(t) == pos(t->p)) rotate(t->p);
            else rotate(t);
        }
        rotate(t);
    }
}

void insert(Tree *&t, Tree *x, Tree *p = nullptr) {
    if (!t) {
        t = x;
        x->p = p;
        return;
    }

    push(t);
    if (x->val < t->val) {
        insert(t->ch[0], x, t);
    } else {
        insert(t->ch[1], x, t);
    }
}

void dfs(Tree *t) {
    if (!t) {
        return;
    }
    push(t);
    dfs(t->ch[0]);
    std::cerr << t->val << " ";
    dfs(t->ch[1]);
}

std::pair<Tree *, Tree *> split(Tree *t, int x) {
    if (!t) {
        return {t, t};
    }
    Tree *v = nullptr;
    Tree *j = t;
    for (Tree *i = t; i; ) {
        push(i);
        j = i;
        if (i->val >= x) {
            v = i;
            i = i->ch[0];
        } else {
            i = i->ch[1];
        }
    }

    splay(j);
    if (!v) {
        return {j, nullptr};
    }

    splay(v);

    Tree *u = v->ch[0];
    if (u) {
        v->ch[0] = u->p = nullptr;
    }
    // std::cerr << "split " << x << "\n";
    // dfs(u);
    // std::cerr << "\n";
    // dfs(v);
    // std::cerr << "\n";
    return {u, v};
}

Tree *merge(Tree *l, Tree *r) {
    if (!l) {
        return r;
    }
    if (!r) {
        return l;
    }
    Tree *i = l;
    while (i->ch[1]) {
        i = i->ch[1];
    }
    splay(i);
    i->ch[1] = r;
    r->p = i;
    return i;
}

2023-09-30

struct Node {
    Node *ch[2], *p;
    bool rev;
    int siz = 1;
    Node() : ch{nullptr, nullptr}, p(nullptr), rev(false) {}
};
void reverse(Node *t) {
    if (t) {
        std::swap(t->ch[0], t->ch[1]);
        t->rev ^= 1;
    }
}
void push(Node *t) {
    if (t->rev) {
        reverse(t->ch[0]);
        reverse(t->ch[1]);
        t->rev = false;
    }
}
void pull(Node *t) {
    t->siz = (t->ch[0] ? t->ch[0]->siz : 0) + 1 + (t->ch[1] ? t->ch[1]->siz : 0);
}
bool isroot(Node *t) {
    return t->p == nullptr || (t->p->ch[0] != t && t->p->ch[1] != t);
}
int pos(Node *t) {
    return t->p->ch[1] == t;
}
void pushAll(Node *t) {
    if (!isroot(t)) {
        pushAll(t->p);
    }
    push(t);
}
void rotate(Node *t) {
    Node *q = t->p;
    int x = !pos(t);
    q->ch[!x] = t->ch[x];
    if (t->ch[x]) {
        t->ch[x]->p = q;
    }
    t->p = q->p;
    if (!isroot(q)) {
        q->p->ch[pos(q)] = t;
    }
    t->ch[x] = q;
    q->p = t;
    pull(q);
}
void splay(Node *t) {
    pushAll(t);
    while (!isroot(t)) {
        if (!isroot(t->p)) {
            if (pos(t) == pos(t->p)) {
                rotate(t->p);
            } else {
                rotate(t);
            }
        }
        rotate(t);
    }
    pull(t);
}
void access(Node *t) {
    for (Node *i = t, *q = nullptr; i; q = i, i = i->p) {
        splay(i);
        i->ch[1] = q;
        pull(i);
    }
    splay(t);
}
void makeroot(Node *t) {
    access(t);
    reverse(t);
}
void link(Node *x, Node *y) {
    makeroot(x);
    x->p = y;
}
void split(Node *x, Node *y) {
    makeroot(x);
    access(y);
}
void cut(Node *x, Node *y) {
    split(x, y);
    x->p = y->ch[0] = nullptr;
    pull(y);
}
int dist(Node *x, Node *y) {
    split(x, y);
    return y->siz - 1;
}

2024-03-30

struct Matrix : std::array<std::array<i64, 4>, 4> {
    Matrix(i64 v = 0) {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                (*this)[i][j] = (i == j ? v : inf);
            }
        }
    }
};

Matrix operator*(const Matrix &a, const Matrix &b) {
    Matrix c(inf);
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                c[i][k] = std::min(c[i][k], a[i][j] + b[j][k]);
            }
        }
        c[i][3] = std::min(c[i][3], a[i][3]);
    }
    c[3][3] = 0;
    return c;
}

struct Node {
    Node *ch[2], *p;
    i64 sumg = 0;
    i64 sumh = 0;
    i64 sumb = 0;
    i64 g = 0;
    i64 h = 0;
    i64 b = 0;
    Matrix mat;
    Matrix prd;
    std::array<i64, 4> ans{};
    Node() : ch{nullptr, nullptr}, p(nullptr) {}

    void update() {
        mat = Matrix(inf);
        mat[0][0] = b + h - g + sumg;
        mat[1][1] = mat[1][2] = mat[1][3] = h + sumh;
        mat[2][0] = mat[2][1] = mat[2][2] = mat[2][3] = b + h + sumb;
        mat[3][3] = 0;
    }
};
void push(Node *t) {

}
void pull(Node *t) {
    t->prd = (t->ch[0] ? t->ch[0]->prd : Matrix()) * t->mat * (t->ch[1] ? t->ch[1]->prd : Matrix());
}
bool isroot(Node *t) {
    return t->p == nullptr || (t->p->ch[0] != t && t->p->ch[1] != t);
}
int pos(Node *t) {
    return t->p->ch[1] == t;
}
void pushAll(Node *t) {
    if (!isroot(t)) {
        pushAll(t->p);
    }
    push(t);
}
void rotate(Node *t) {
    Node *q = t->p;
    int x = !pos(t);
    q->ch[!x] = t->ch[x];
    if (t->ch[x]) {
        t->ch[x]->p = q;
    }
    t->p = q->p;
    if (!isroot(q)) {
        q->p->ch[pos(q)] = t;
    }
    t->ch[x] = q;
    q->p = t;
    pull(q);
}
void splay(Node *t) {
    pushAll(t);
    while (!isroot(t)) {
        if (!isroot(t->p)) {
            if (pos(t) == pos(t->p)) {
                rotate(t->p);
            } else {
                rotate(t);
            }
        }
        rotate(t);
    }
    pull(t);
}

std::array<i64, 4> get(Node *t) {
    std::array<i64, 4> ans;
    ans.fill(inf);
    ans[3] = 0;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            ans[i] = std::min(ans[i], t->prd[i][j]);
        }
    }
    return ans;
}

void access(Node *t) {
    std::array<i64, 4> old{};
    for (Node *i = t, *q = nullptr; i; q = i, i = i->p) {
        splay(i);
        if (i->ch[1]) {
            auto res = get(i->ch[1]);
            i->sumg += res[0];
            i->sumh += std::min({res[1], res[2], res[3]});
            i->sumb += std::min({res[0], res[1], res[2], res[3]});
        }
        i->ch[1] = q;
        i->sumg -= old[0];
        i->sumh -= std::min({old[1], old[2], old[3]});
        i->sumb -= std::min({old[0], old[1], old[2], old[3]});
        old = get(i);
        i->update();
        pull(i);
    }
    splay(t);
}

08 - 其他平衡树

2023-08-04

struct Node {
    Node *l = nullptr;
    Node *r = nullptr;
    int sum = 0;
    int sumodd = 0;

    Node(Node *t) {
        if (t) {
            *this = *t;
        }
    }
};

Node *add(Node *t, int l, int r, int x, int v) {
    t = new Node(t);
    t->sum += v;
    t->sumodd += (x % 2) * v;
    if (r - l == 1) {
        return t;
    }
    int m = (l + r) / 2;
    if (x < m) {
        t->l = add(t->l, l, m, x, v);
    } else {
        t->r = add(t->r, m, r, x, v);
    }
    return t;
}

int query1(Node *t1, Node *t2, int l, int r, int k) {
    if (r - l == 1) {
        return l;
    }
    int m = (l + r) / 2;
    int odd = (t1 && t1->r ? t1->r->sumodd : 0) - (t2 && t2->r ? t2->r->sumodd : 0);
    int cnt = (t1 && t1->r ? t1->r->sum : 0) - (t2 && t2->r ? t2->r->sum : 0);
    if (odd > 0 || cnt > k) {
        return query1(t1 ? t1->r : t1, t2 ? t2->r : t2, m, r, k);
    } else {
        return query1(t1 ? t1->l : t1, t2 ? t2->l : t2, l, m, k - cnt);
    }
}

std::array<int, 3> query2(Node *t1, Node *t2, int l, int r, int k) {
    if (r - l == 1) {
        int cnt = (t1 ? t1->sumodd : 0) - (t2 ? t2->sumodd : 0);
        return {l, cnt, k};
    }
    int m = (l + r) / 2;
    int cnt = (t1 && t1->r ? t1->r->sumodd : 0) - (t2 && t2->r ? t2->r->sumodd : 0);
    if (cnt > k) {
        return query2(t1 ? t1->r : t1, t2 ? t2->r : t2, m, r, k);
    } else {
        return query2(t1 ? t1->l : t1, t2 ? t2->l : t2, l, m, k - cnt);
    }
}

2023-08-26

struct Node {
    Node *l = nullptr;
    Node *r = nullptr;
    int cnt = 0;
};

Node *add(Node *t, int l, int r, int x) {
    if (t) {
        t = new Node(*t);
    } else {
        t = new Node;
    }
    t->cnt += 1;
    if (r - l == 1) {
        return t;
    }
    int m = (l + r) / 2;
    if (x < m) {
        t->l = add(t->l, l, m, x);
    } else {
        t->r = add(t->r, m, r, x);
    }
    return t;
}

int query(Node *t1, Node *t2, int l, int r, int x) {
    int cnt = (t2 ? t2->cnt : 0) - (t1 ? t1->cnt : 0);
    if (cnt == 0 || l >= x) {
        return -1;
    }
    if (r - l == 1) {
        return l;
    }
    int m = (l + r) / 2;
    int res = query(t1 ? t1->r : t1, t2 ? t2->r : t2, m, r, x);
    if (res == -1) {
        res = query(t1 ? t1->l : t1, t2 ? t2->l : t2, l, m, x);
    }
    return res;
}

2023-04-03

struct Info {
    int imp = 0;
    int id = 0;
};

Info operator+(Info a, Info b) {
    return {std::max(a.imp, b.imp), 0};
}

struct Node {
    int w = rng();
    Info info;
    Info sum;
    int siz = 1;
    Node *l = nullptr;
    Node *r = nullptr;
};

void pull(Node *t) {
    t->sum = t->info;
    t->siz = 1;
    if (t->l) {
        t->sum = t->l->sum + t->sum;
        t->siz += t->l->siz;
    }
    if (t->r) {
        t->sum = t->sum + t->r->sum;
        t->siz += t->r->siz;
    }
}

std::pair<Node *, Node *> splitAt(Node *t, int p) {
    if (!t) {
        return {t, t};
    }
    if (p <= (t->l ? t->l->siz : 0)) {
        auto [l, r] = splitAt(t->l, p);
        t->l = r;
        pull(t);
        return {l, t};
    } else {
        auto [l, r] = splitAt(t->r, p - 1 - (t->l ? t->l->siz : 0));
        t->r = l;
        pull(t);
        return {t, r};
    }
}

void insertAt(Node *&t, int p, Node *x) {
    if (!t) {
        t = x;
        return;
    }
    if (x->w < t->w) {
        auto [l, r] = splitAt(t, p);
        t = x;
        t->l = l;
        t->r = r;
        pull(t);
        return;
    }
    if (p <= (t->l ? t->l->siz : 0)) {
        insertAt(t->l, p, x);
    } else {
        insertAt(t->r, p - 1 - (t->l ? t->l->siz : 0), x);
    }
    pull(t);
}

Node *merge(Node *a, Node *b) {
    if (!a) {
        return b;
    }
    if (!b) {
        return a;
    }

    if (a->w < b->w) {
        a->r = merge(a->r, b);
        pull(a);
        return a;
    } else {
        b->l = merge(a, b->l);
        pull(b);
        return b;
    }
}

int query(Node *t, int v) {
    if (!t) {
        return 0;
    }
    if (t->sum.imp < v) {
        return t->siz;
    }
    int res = query(t->r, v);
    if (res != (t->r ? t->r->siz : 0)) {
        return res;
    }
    if (t->info.imp > v) {
        return res;
    }
    return res + 1 + query(t->l, v);
}

void dfs(Node *t) {
    if (!t) {
        return;
    }
    dfs(t->l);
    std::cout << t->info.id << " ";
    dfs(t->r);
}

2023-07-31

struct Node {
    Node *l = nullptr;
    Node *r = nullptr;
    int cnt = 0;
    int cntnew = 0;
};

Node *add(int l, int r, int x, int isnew) {
    Node *t = new Node;
    t->cnt = 1;
    t->cntnew = isnew;
    if (r - l == 1) {
        return t;
    }
    int m = (l + r) / 2;
    if (x < m) {
        t->l = add(l, m, x, isnew);
    } else {
        t->r = add(m, r, x, isnew);
    }
    return t;
}

struct Info {
    Node *t = nullptr;
    int psum = 0;
    bool rev = false;
};

void pull(Node *t) {
    t->cnt = (t->l ? t->l->cnt : 0) + (t->r ? t->r->cnt : 0);
    t->cntnew = (t->l ? t->l->cntnew : 0) + (t->r ? t->r->cntnew : 0);
}

std::pair<Node *, Node *> split(Node *t, int l, int r, int x, bool rev) {
    if (!t) {
        return {t, t};
    }
    if (x == 0) {
        return {nullptr, t};
    }
    if (x == t->cnt) {
        return {t, nullptr};
    }
    if (r - l == 1) {
        Node *t2 = new Node;
        t2->cnt = t->cnt - x;
        t->cnt = x;
        return {t, t2};
    }
    Node *t2 = new Node;
    int m = (l + r) / 2;
    if (!rev) {
        if (t->l && x <= t->l->cnt) {
            std::tie(t->l, t2->l) = split(t->l, l, m, x, rev);
            t2->r = t->r;
            t->r = nullptr;
        } else {
            std::tie(t->r, t2->r) = split(t->r, m, r, x - (t->l ? t->l->cnt : 0), rev);
        }
    } else {
        if (t->r && x <= t->r->cnt) {
            std::tie(t->r, t2->r) = split(t->r, m, r, x, rev);
            t2->l = t->l;
            t->l = nullptr;
        } else {
            std::tie(t->l, t2->l) = split(t->l, l, m, x - (t->r ? t->r->cnt : 0), rev);
        }
    }
    pull(t);
    pull(t2);
    return {t, t2};
}

Node *merge(Node *t1, Node *t2, int l, int r) {
    if (!t1) {
        return t2;
    }
    if (!t2) {
        return t1;
    }
    if (r - l == 1) {
        t1->cnt += t2->cnt;
        t1->cntnew += t2->cntnew;
        delete t2;
        return t1;
    }
    int m = (l + r) / 2;
    t1->l = merge(t1->l, t2->l, l, m);
    t1->r = merge(t1->r, t2->r, m, r);
    delete t2;
    pull(t1);
    return t1;
}

09 - 分数四则运算（Frac）

2023-04-23

template<class T>
struct Frac {
    T num;
    T den;
    Frac(T num_, T den_) : num(num_), den(den_) {
        if (den < 0) {
            den = -den;
            num = -num;
        }
    }
    Frac() : Frac(0, 1) {}
    Frac(T num_) : Frac(num_, 1) {}
    explicit operator double() const {
        return 1. * num / den;
    }
    Frac &operator+=(const Frac &rhs) {
        num = num * rhs.den + rhs.num * den;
        den *= rhs.den;
        return *this;
    }
    Frac &operator-=(const Frac &rhs) {
        num = num * rhs.den - rhs.num * den;
        den *= rhs.den;
        return *this;
    }
    Frac &operator*=(const Frac &rhs) {
        num *= rhs.num;
        den *= rhs.den;
        return *this;
    }
    Frac &operator/=(const Frac &rhs) {
        num *= rhs.den;
        den *= rhs.num;
        if (den < 0) {
            num = -num;
            den = -den;
        }
        return *this;
    }
    friend Frac operator+(Frac lhs, const Frac &rhs) {
        return lhs += rhs;
    }
    friend Frac operator-(Frac lhs, const Frac &rhs) {
        return lhs -= rhs;
    }
    friend Frac operator*(Frac lhs, const Frac &rhs) {
        return lhs *= rhs;
    }
    friend Frac operator/(Frac lhs, const Frac &rhs) {
        return lhs /= rhs;
    }
    friend Frac operator-(const Frac &a) {
        return Frac(-a.num, a.den);
    }
    friend bool operator==(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den == rhs.num * lhs.den;
    }
    friend bool operator!=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den != rhs.num * lhs.den;
    }
    friend bool operator<(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den < rhs.num * lhs.den;
    }
    friend bool operator>(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den > rhs.num * lhs.den;
    }
    friend bool operator<=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den <= rhs.num * lhs.den;
    }
    friend bool operator>=(const Frac &lhs, const Frac &rhs) {
        return lhs.num * rhs.den >= rhs.num * lhs.den;
    }
    friend std::ostream &operator<<(std::ostream &os, Frac x) {
        T g = std::gcd(x.num, x.den);
        if (x.den == g) {
            return os << x.num / g;
        } else {
            return os << x.num / g << "/" << x.den / g;
        }
    }
};

10 - 线性基（Basis）

2023-12-03

struct Basis {
    int a[20] {};
    int t[20] {};

    Basis() {
        std::fill(t, t + 20, -1);
    }

    void add(int x, int y = 1E9) {
        for (int i = 0; i < 20; i++) {
            if (x >> i & 1) {
                if (y > t[i]) {
                    std::swap(a[i], x);
                    std::swap(t[i], y);
                }
                x ^= a[i];
            }
        }
    }

    bool query(int x, int y = 0) {
        for (int i = 0; i < 20; i++) {
            if ((x >> i & 1) && t[i] >= y) {
                x ^= a[i];
            }
        }
        return x == 0;
    }
};

五、字符串

01 - 马拉车（Manacher）

2023-05-14

std::vector<int> manacher(std::string s) {
    std::string t = "#";
    for (auto c : s) {
        t += c;
        t += '#';
    }
    int n = t.size();
    std::vector<int> r(n);
    for (int i = 0, j = 0; i < n; i++) {
        if (2 * j - i >= 0 && j + r[j] > i) {
            r[i] = std::min(r[2 * j - i], j + r[j] - i);
        }
        while (i - r[i] >= 0 && i + r[i] < n && t[i - r[i]] == t[i + r[i]]) {
            r[i] += 1;
        }
        if (i + r[i] > j + r[j]) {
            j = i;
        }
    }
    return r;
}

02 - Z函数

2023-08-11

std::vector<int> zFunction(std::string s) {
    int n = s.size();
    std::vector<int> z(n + 1);
    z[0] = n;
    for (int i = 1, j = 1; i < n; i++) {
        z[i] = std::max(0, std::min(j + z[j] - i, z[i - j]));
        while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
            z[i]++;
        }
        if (i + z[i] > j + z[j]) {
            j = i;
        }
    }
    return z;
}

03 - 后缀数组（SA）

2023-03-14

struct SuffixArray {
    int n;
    std::vector<int> sa, rk, lc;
    SuffixArray(const std::string &s) {
        n = s.length();
        sa.resize(n);
        lc.resize(n - 1);
        rk.resize(n);
        std::iota(sa.begin(), sa.end(), 0);
        std::sort(sa.begin(), sa.end(), [&](int a, int b) {return s[a] < s[b];});
        rk[sa[0]] = 0;
        for (int i = 1; i < n; ++i)
            rk[sa[i]] = rk[sa[i - 1]] + (s[sa[i]] != s[sa[i - 1]]);
        int k = 1;
        std::vector<int> tmp, cnt(n);
        tmp.reserve(n);
        while (rk[sa[n - 1]] < n - 1) {
            tmp.clear();
            for (int i = 0; i < k; ++i)
                tmp.push_back(n - k + i);
            for (auto i : sa)
                if (i >= k)
                    tmp.push_back(i - k);
            std::fill(cnt.begin(), cnt.end(), 0);
            for (int i = 0; i < n; ++i)
                ++cnt[rk[i]];
            for (int i = 1; i < n; ++i)
                cnt[i] += cnt[i - 1];
            for (int i = n - 1; i >= 0; --i)
                sa[--cnt[rk[tmp[i]]]] = tmp[i];
            std::swap(rk, tmp);
            rk[sa[0]] = 0;
            for (int i = 1; i < n; ++i)
                rk[sa[i]] = rk[sa[i - 1]] + (tmp[sa[i - 1]] < tmp[sa[i]] || sa[i - 1] + k == n || tmp[sa[i - 1] + k] < tmp[sa[i] + k]);
            k *= 2;
        }
        for (int i = 0, j = 0; i < n; ++i) {
            if (rk[i] == 0) {
                j = 0;
            } else {
                for (j -= j > 0; i + j < n && sa[rk[i] - 1] + j < n && s[i + j] == s[sa[rk[i] - 1] + j]; )
                    ++j;
                lc[rk[i] - 1] = j;
            }
        }
    }
};

04A - 后缀自动机（SuffixAutomaton 旧版）

2022-08-17

struct SuffixAutomaton {
    static constexpr int ALPHABET_SIZE = 26, N = 5e5;
    struct Node {
        int len;
        int link;
        int next[ALPHABET_SIZE];
        Node() : len(0), link(0), next{} {}
    } t[2 * N];
    int cntNodes;
    SuffixAutomaton() {
        cntNodes = 1;
        std::fill(t[0].next, t[0].next + ALPHABET_SIZE, 1);
        t[0].len = -1;
    }
    int extend(int p, int c) {
        if (t[p].next[c]) {
            int q = t[p].next[c];
            if (t[q].len == t[p].len + 1)
                return q;
            int r = ++cntNodes;
            t[r].len = t[p].len + 1;
            t[r].link = t[q].link;
            std::copy(t[q].next, t[q].next + ALPHABET_SIZE, t[r].next);
            t[q].link = r;
            while (t[p].next[c] == q) {
                t[p].next[c] = r;
                p = t[p].link;
            }
            return r;
        }
        int cur = ++cntNodes;
        t[cur].len = t[p].len + 1;
        while (!t[p].next[c]) {
            t[p].next[c] = cur;
            p = t[p].link;
        }
        t[cur].link = extend(p, c);
        return cur;
    }
};

04B - 后缀自动机（SAM 新版）

2023-05-27

struct SAM {
    static constexpr int ALPHABET_SIZE = 26;
    struct Node {
        int len;
        int link;
        std::array<int, ALPHABET_SIZE> next;
        Node() : len{}, link{}, next{} {}
    };
    std::vector<Node> t;
    SAM() {
        init();
    }
    void init() {
        t.assign(2, Node());
        t[0].next.fill(1);
        t[0].len = -1;
    }
    int newNode() {
        t.emplace_back();
        return t.size() - 1;
    }
    int extend(int p, int c) {
        if (t[p].next[c]) {
            int q = t[p].next[c];
            if (t[q].len == t[p].len + 1) {
                return q;
            }
            int r = newNode();
            t[r].len = t[p].len + 1;
            t[r].link = t[q].link;
            t[r].next = t[q].next;
            t[q].link = r;
            while (t[p].next[c] == q) {
                t[p].next[c] = r;
                p = t[p].link;
            }
            return r;
        }
        int cur = newNode();
        t[cur].len = t[p].len + 1;
        while (!t[p].next[c]) {
            t[p].next[c] = cur;
            p = t[p].link;
        }
        t[cur].link = extend(p, c);
        return cur;
    }
    int extend(int p, char c, char offset = 'a') {
        return extend(p, c - offset);
    }

    int next(int p, int x) {
        return t[p].next[x];
    }

    int next(int p, char c, char offset = 'a') {
        return next(p, c - 'a');
    }

    int link(int p) {
        return t[p].link;
    }

    int len(int p) {
        return t[p].len;
    }

    int size() {
        return t.size();
    }
};

05 - 回文自动机（PAM）

2023-05-19

struct PAM {
    static constexpr int ALPHABET_SIZE = 28;
    struct Node {
        int len;
        int link;
        int cnt;
        std::array<int, ALPHABET_SIZE> next;
        Node() : len{}, link{}, cnt{}, next{} {}
    };
    std::vector<Node> t;
    int suff;
    std::string s;
    PAM() {
        init();
    }
    void init() {
        t.assign(2, Node());
        t[0].len = -1;
        suff = 1;
        s.clear();
    }
    int newNode() {
        t.emplace_back();
        return t.size() - 1;
    }

    bool add(char c, char offset = 'a') {
        int pos = s.size();
        s += c;
        int let = c - offset;
        int cur = suff, curlen = 0;

        while (true) {
            curlen = t[cur].len;
            if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos])
                break;
            cur = t[cur].link;
        }
        if (t[cur].next[let]) {
            suff = t[cur].next[let];
            return false;
        }

        int num = newNode();
        suff = num;
        t[num].len = t[cur].len + 2;
        t[cur].next[let] = num;

        if (t[num].len == 1) {
            t[num].link = 1;
            t[num].cnt = 1;
            return true;
        }

        while (true) {
            cur = t[cur].link;
            curlen = t[cur].len;
            if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) {
                t[num].link = t[cur].next[let];
                break;
            }
        }

        t[num].cnt = 1 + t[t[num].link].cnt;

        return true;
    }
};

PAM pam;

06A - AC自动机（AC 旧版）

2021-07-07

constexpr int N = 3e5 + 30, A = 26;

struct Node {
    int fail;
    int sum;
    int next[A];
    Node() : fail(-1), sum(0) {
        std::memset(next, -1, sizeof(next));
    }
} node[N];

int cnt = 0;
int bin[N];
int nBin = 0;

int newNode() {
    int p = nBin > 0 ? bin[--nBin] : cnt++;
    node[p] = Node();
    return p;
}

struct AC {
    std::vector<int> x;
    AC(AC &&a) : x(std::move(a.x)) {}
    AC(std::vector<std::string> s, std::vector<int> w) {
        x = {newNode(), newNode()};
        std::fill(node[x[0]].next, node[x[0]].next + A, x[1]);
        node[x[1]].fail = x[0];

        for (int i = 0; i < int(s.size()); i++) {
            int p = x[1];
            for (int j = 0; j < int(s[i].length()); j++) {
                int c = s[i][j] - 'a';
                if (node[p].next[c] == -1) {
                    int u = newNode();
                    x.push_back(u);
                    node[p].next[c] = u;
                }
                p = node[p].next[c];
            }
            node[p].sum += w[i];
        }

        std::queue<int> que;
        que.push(x[1]);
        while (!que.empty()) {
            int u = que.front();
            que.pop();
            node[u].sum += node[node[u].fail].sum;
            for (int c = 0; c < A; c++) {
                if (node[u].next[c] == -1) {
                    node[u].next[c] = node[node[u].fail].next[c];
                } else {
                    node[node[u].next[c]].fail = node[node[u].fail].next[c];
                    que.push(node[u].next[c]);
                }
            }
        }
    }
    ~AC() {
        for (auto p : x) {
            bin[nBin++] = p;
        }
    }
    i64 query(const std::string &s) const {
        i64 ans = 0;
        int p = x[1];
        for (int i = 0; i < int(s.length()); i++)  {
            int c = s[i] - 'a';
            p = node[p].next[c];
            ans += node[p].sum;
        }
        return ans;
    }
};

06B - AC自动机（AhoCorasick 新版）

2023-04-07

struct AhoCorasick {
    static constexpr int ALPHABET = 26;
    struct Node {
        int len;
        int link;
        std::array<int, ALPHABET> next;
        Node() : link{}, next{} {}
    };

    std::vector<Node> t;

    AhoCorasick() {
        init();
    }

    void init() {
        t.assign(2, Node());
        t[0].next.fill(1);
        t[0].len = -1;
    }

    int newNode() {
        t.emplace_back();
        return t.size() - 1;
    }

    int add(const std::vector<int> &a) {
        int p = 1;
        for (auto x : a) {
            if (t[p].next[x] == 0) {
                t[p].next[x] = newNode();
                t[t[p].next[x]].len = t[p].len + 1;
            }
            p = t[p].next[x];
        }
        return p;
    }

    int add(const std::string &a, char offset = 'a') {
        std::vector<int> b(a.size());
        for (int i = 0; i < a.size(); i++) {
            b[i] = a[i] - offset;
        }
        return add(b);
    }

    void work() {
        std::queue<int> q;
        q.push(1);

        while (!q.empty()) {
            int x = q.front();
            q.pop();

            for (int i = 0; i < ALPHABET; i++) {
                if (t[x].next[i] == 0) {
                    t[x].next[i] = t[t[x].link].next[i];
                } else {
                    t[t[x].next[i]].link = t[t[x].link].next[i];
                    q.push(t[x].next[i]);
                }
            }
        }
    }

    int next(int p, int x) {
        return t[p].next[x];
    }

    int next(int p, char c, char offset = 'a') {
        return next(p, c - 'a');
    }

    int link(int p) {
        return t[p].link;
    }

    int len(int p) {
        return t[p].len;
    }

    int size() {
        return t.size();
    }
};

07 - 随机生成模底字符串哈希（例题）

2022-06-09

#include <bits/stdc++.h>

using i64 = long long;

bool isprime(int n) {
    if (n <= 1) {
        return false;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int findPrime(int n) {
    while (!isprime(n)) {
        n++;
    }
    return n;
}

using Hash = std::array<int, 2>;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

    const int P = findPrime(rng() % 900000000 + 100000000);

    std::string s, x;
    std::cin >> s >> x;

    int n = s.length();
    int m = x.length();

    std::vector<int> h(n + 1), p(n + 1);
    for (int i = 0; i < n; i++) {
        h[i + 1] = (10LL * h[i] + s[i] - '0') % P;
    }
    p[0] = 1;
    for (int i = 0; i < n; i++) {
        p[i + 1] = 10LL * p[i] % P;
    }

    auto get = [&](int l, int r) {
        return (h[r] + 1LL * (P - h[l]) * p[r - l]) % P;
    };

    int px = 0;
    for (auto c : x) {
        px = (10LL * px + c - '0') % P;
    }

    for (int i = 0; i <= n - 2 * (m - 1); i++) {
        if ((get(i, i + m - 1) + get(i + m - 1, i + 2 * m - 2)) % P == px) {
            std::cout << i + 1 << " " << i + m - 1 << "\n";
            std::cout << i + m << " " << i + 2 * m - 2 << "\n";
            return 0;
        }
    }

    std::vector<int> z(m + 1), f(n + 1);
    z[0] = m;

    for (int i = 1, j = -1; i < m; i++) {
        if (j != -1) {
            z[i] = std::max(0, std::min(j + z[j] - i, z[i - j]));
        }
        while (z[i] + i < m && x[z[i]] == x[z[i] + i]) {
            z[i]++;
        }
        if (j == -1 || i + z[i] > j + z[j]) {
            j = i;
        }
    }
    for (int i = 0, j = -1; i < n; i++) {
        if (j != -1) {
            f[i] = std::max(0, std::min(j + f[j] - i, z[i - j]));
        }
        while (f[i] + i < n && f[i] < m && x[f[i]] == s[f[i] + i]) {
            f[i]++;
        }
        if (j == -1 || i + f[i] > j + f[j]) {
            j = i;
        }
    }

    for (int i = 0; i + m <= n; i++) {
        int l = std::min(m, f[i]);

        for (auto j : { m - l, m - l - 1 }) {
            if (j <= 0) {
                continue;
            }
            if (j <= i && (get(i - j, i) + get(i, i + m)) % P == px) {
                std::cout << i - j + 1 << " " << i << "\n";
                std::cout << i + 1 << " " << i + m << "\n";
                return 0;
            }
            if (i + m + j <= n && (get(i, i + m) + get(i + m, i + m + j)) % P == px) {
                std::cout << i + 1 << " " << i + m << "\n";
                std::cout << i + m + 1 << " " << i + m + j << "\n";
                return 0;
            }
        }
    }

    return 0;
}

本文转自 https://www.cnblogs.com/WIDA/p/17633758.html#01b---%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84fenwick-%E6%96%B0%E7%89%88，如有侵权，请联系删除。

Educational Codeforces Round 168 (Rated for Div.2)

Thu, 08 Aug 2024 23:43:50 GMT

A Strong Password

题目描述

给定字符串，现在让我们添加一个字符，使得字符串的价值最大，对于价值是这样看的

第一个字符的价值为2，

后面的字符若与前面的字符相同，则价值为1，否则价值为2。让我们输出价值最大的一种情况

解题思路

我们可以遍历每一个位置，然后找出在哪个位置插入的价值最大，毕竟 n 的取值较小，最后再将其替换为与前后位置不相等的字符即可。

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	std::string s, t;
	std::cin >> s;

	if(s.size() == 1) {
		std::cout << (s[0] == 'z' ? 'a' : 'z') << s[0] << endl;
		return;
	}
	int ma = 0;
	for(int i = 0; i < s.size(); i++) {
		auto w = s;
		w.insert(w.begin() + i, '.');
		int res = 2;
		for(int j = 1; j < w.size(); j++) {
			if (w[j] == w[j - 1]) {
				res++;
			} else res += 2;
		}
		if (ma <= res) {
			ma = res;
			t = w;
		}
	}

	int pos = t.find('.');
	int t1 = pos - 1, t2 = pos + 1;
	for(auto i = 'a'; i <= 'z'; i++) {
		if (i != t[t1] && i != t[t2]) {
			t[pos] = i;
			break;
		}
	}
	std::cout << t << endl;
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

B Make Three Regions

题目描述

给定一个 $2 * n$ 的一个字符矩阵，其中 . 是开放的，而 X 是阻塞的，现在让我们判断有几个点可以将这个字符矩阵分为三个联通的区域。

解题思路

刚开始的时候，以为是有几个联通的区域，写完 dfs 后，什么WA1，我连 dfs 都能写错，结果自己是小丑（小插曲）可以通过给出的图例看出一列只可能有一个点能成为分割点，那么能成为分割点就需要满足四个条件，

$s[0][i] ='.' && s[1][i] ='.'$

$s[0][i - 1] \neq s[1][i - 1]$

$s[0][i+1] \neq s[1][i+1]$

$s[0][i-1] = s[0][i + 1]$ 既然这样，那就简单了

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
	int n = 2, m;
	std::cin >> m;
	std::vector<std::string> s(n);
	for(int i = 0; i < n; i++) std::cin >> s[i];

	int ans = 0;
	for(int i = 1; i < m - 1; i++) {
		bool k = true;
		k &= (s[0][i] == '.' && s[1][i] == '.');
		k &= (s[0][i - 1] != s[1][i - 1]);
		k &= (s[0][i + 1] != s[1][i + 1]);
		k &= (s[0][i - 1] == s[0][i + 1]);
		ans += k ? 1 : 0;
	}
	std::cout << ans << endl;
}

signed main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr), std::cout.tie(nullptr);
	int Lazy_boy_ = 1;
	std::cin >> Lazy_boy_;
	while (Lazy_boy_--) solve();
	return 0;
}

C Even Positions

题目描述

给定字符串，让我们输出字符串匹配的()的最短距离，距离是$pos('()') - pos('(')$

解题思路

手指玩玩就行了

参考代码

#include<bits/stdc++.h>

#define int long long
#define endl '\n'
#define pii std::pair<int ,int>
#define fix(x) std::fixed << std::setprecision(x)
const int inf = 1e17 + 50, MAX_N = 1e5 + 50, mod = 1e9 + 7;

void solve () {
    int n;
    std::cin >> n;

    std::string s;
    std::cin >> s;

    int pre = 0, ans = 0;
    for(int i = 0; i < n; i += 2) {
       if (pre > 0) {
          pre--;
       } else {
          pre++;
       }       ans += pre;
       pre += (s[i + 1] == '(' ? 1 : -1);
       ans += pre;
    }
    std::cout << ans << endl;
}

signed main () {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--) solve();
    return 0;
}

Educational Codeforces Round 161 (Rated for Div.2)

Thu, 08 Aug 2024 23:42:58 GMT

A Tricky Template

题目描述

给一个数字n和三个长度为n的字符串 a,b,c。找一个模板使得字符串a,b匹配，而c不匹配,是否存在这样一个模板. 匹配的定义是:当模板字母为小写时,两个字符串字符相同,为大写时,两个字符不同,这样的两个字符串则匹配

解题思路

我们可以直接得出当a字符串和b字符串都不等于c字符串时,就存在这样一个模板使得满足题意

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e18 + 50, pi = 3;
[[maybe_unused]]typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    std::string a, b, c;
    std::cin >> a >> b >> c;
    for (int i = 0; i < n; i++)
        if (a[i] != c[i] && b[i] != c[i]) {
            std::cout << "YES" << endl;
            return;
        }
    std::cout << "NO" << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--) solve();
    return 0;
}

B Forming Triangles

题目描述

给定一个长度为n的一个数组a,对于a[i]来说,就是一个长度为2^a[i]的木棒,现在问:用这些木棒能组成多少个三角形.

解题思路

对于一个三角形来说,两边之和大于第三边,两边之差小于第三边,不可能存在两边之和等于第三边,那么我们就可以得到要组成一个三角形就至少需要两条边相等,第三边小于等于这两个边,那么这个问题就成了一个组合数问题

组合数用C(cnt, m)来表示,其中cnt为这个数的总数,m为我们需要选的个数; cnt可以用map来写,对数组去重,遍历一次数组,s表示比遍历到当前数字小的个数即写成ans += C(mp[a[i]], 3) + C(mp[a[i]], 2) * s

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e18 + 50, pi = 3;

int C(int n, int m) {
    if (n < m) return 0;
    int ans = 1;
    for (int i = 1; i <= m; i++)
        ans = ans * (n - m + i) / i;
    return ans;
}

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n, 0ll);
    std::map<int, int> mp;
    for (int i = 0; i < n; i++) std::cin >> a[i], mp[a[i]]++;
    std::sort(a.begin(), a.end());
    n = std::unique(a.begin(), a.end()) - a.begin();
    int ans = C(mp[a[0]], 3), s = 0;
    for (int i = 1; i < n; i++) {
        int t = mp[a[i]];
        s += mp[a[i - 1]];
        ans += C(t, 3) + C(t, 2) * s;
    }
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Closest Cities

题目描述

在x轴上有n个城市,其位置为a[i],并且序列a按升序排列,保证每个城市只有一个最近的城市若i的最近城市是i+1则花费1,否则花费|a[i]-a[i+1]|,现在有q次询问问:每次询问城市x到城市y的最小花费.

解题思路

先分析一下x<y,我们只有一直向右走才会有最小花费,那就需要判断当前城市的最近城市是否为下一个城市. 由于是一直向右走,我么就可以用前缀和求解这个问题. 同理,x>y时,我们是从右向左走,可以用后缀和求解.

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e18 + 50, pi = 3;

void solve() {
    int n, q;
    std::cin >> n;
    std::vector<int> a(n + 1, 0ll);
    auto s1 = a, s2 = a;
    for (int i = 1; i <= n; i++) std::cin >> a[i];
    s1[2] = 1;
    for (int i = 2; i < n; i++) {
        if (a[i] - a[i - 1] > a[i + 1] - a[i]) s1[i + 1] = s1[i] + 1;
        else s1[i + 1] = s1[i] + abs(a[i + 1] - a[i]);
    }
    s2[n - 1] = 1;
    for (int i = n - 1; i > 1; i--) {
        if (a[i] - a[i - 1] > a[i + 1] - a[i]) s2[i - 1] = s2[i] + abs(a[i] - a[i - 1]);
        else s2[i - 1] = s2[i] + 1;
    }
//    for (int i = 1; i <= n; i++)
//        std::cout << s1[i] << ' ';
//    std::cout << endl;
//    for (int i = 1; i <= n; i++)
//        std::cout << s2[i] << ' ';
    std::cout << endl;
    std::cin >> q;
    while (q--) {
        int x, y;
        std::cin >> x >> y;
        if (x < y)
            std::cout << s1[y] - s1[x] << endl;
        else
            std::cout << s2[y] - s2[x] << endl;
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Educational Codeforces Round 160 (Rated for Div.2)

Thu, 08 Aug 2024 23:41:58 GMT

A Rating Increas

题目大意

给定一个数字,让我们拆分成两个数,这两个数满足以下条件:

a < b.

两个数没有前缀0.

问:输出满足条件的数a , b.

解题思路

直接暴力循环这个数的位数次,若满足a < b,再判断两个数的位数和是否与拆分前相同.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    int n, cnt = 1, k = 0;
    std::cin >> n;
    int s = n;
    while (s) {
        k++;
        s /= 10;
    }
    int t = k;
    while (k--) {
        int w = n;
        int a = w / cnt, b = w % cnt;
        int x = a, y = b;
        int s1 = 0, s2 = 0;
        while (x) {
            s1++;
            x /= 10;
        }
        while (y) {
            s2++;
            y /= 10;
        }
        if (a < b && s1 + s2 == t) {
            std::cout << a << " " << b << endl;
            return;
        }
        cnt *= 10;
    }
    std::cout << -1 << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Swap and Delete

题目大意

给一个01字符串s,现在有以下操作:

交换s[i],s[j],此操作花费为0.

删除s[i],此操作花费一个金币.

将修改后的字符串记录为t. 问:至少花费多少金币,使得t[i] != s[i] (0 <= i <= t.size()).

解题思路

我们可以记一下有多少个0 和多少个1, 然后我们遍历一次字符串,check当前0的个数是否大于1的总数和当前1的个数是否大于0的总数

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    std::string s;
    std::cin >> s;
    int s0 = 0, s1 = 0;
    for (auto i: s)
        s0 += (i == '0'), s1 += (i == '1');
    int cnt0 = 0, cnt1 = 0, ans = 0;
    for (int i = 0; i < (int) s.size(); i++) {
        cnt0 += (s[i] == '0'), cnt1 += (s[i] == '1');
        if (s0 >= cnt1 && s1 >= cnt0)
            ans = std::max(ans, i + 1);
    }
    std::cout << (int) s.size() - ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Game with Multiset

题目大意

有两种查询类型:

ADD x,即在集合中添加2^x的元素.

GET w,即询问集合中的某子集之和,能否等于w.

解题思路

很显然,本题考查位运算,用数组模拟,其中cnt[i]表示集合中2^i的元素个数.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> cnt(32, 0ll);
    auto calc = [&](int x) {
        for (int i = 31; i >= 0; i--) {
            int l = 0, r = cnt[i], s = 0;
            while (l <= r) {
                int mid = (l + r + 1) >> 1;
                if (mid * (1 << i) <= x)
                    s = mid, l = mid + 1;
                else
                    r = mid - 1;
            }
            x -= (1 << i) * s;
        }
        std::cout << (x == 0 ? "YES" : "NO") << endl;
    };
    while (n--) {
        int t, v;
        std::cin >> t >> v;
        if (t == 1)
            cnt[v]++;
        else
            calc(v);
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
//    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Educational Codeforces Round 159 (Rated for Div.2)

Thu, 08 Aug 2024 23:40:53 GMT

A Binary Imbalance

题目大意

给定一个长度为n的一个01字符串，我们执行以下操作：当s[i]!=s[i+1]在中间插入0 问：是否可以实现0的个数大于1的个数

解题思路

由题意可以明显看出只要有0就可以实现。下面简单分析下：

0的个数大于0，1111110我们可以在子串10中间一直插入0

0的个数为0时， 11111111不可能在字符串中插入0

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    for(auto i : s)
        if(i == '0'){
            std::cout << "YES" << endl;
            return;
        }
        std::cout << "NO" << endl;
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

B Getting Points(贪心)

题目大意

n天里面要获得p分,可以通过两个路径获取分数:

每天上一堂课,可获得i分.

进行一次实践,可获得t分,但是实践==每七天才会有一个==, ==每一天最多可以做两个实践==

其中, 一天可以选择休息或者学习, 问最多可以休息多少天.

解题思路

可以将所有任务放在最后几天

代码

(大佬们指点一下)

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n, p, L, t;
    std::cin >> n >> p >> L >> t;
    int l = 1, r = n, ans =0 ;
    while(l <= r){
        int mid =(l + r)>>1;
        if((n - mid + 1)* L +std::min((n + 6) / 7,(n - mid + 1)* 2 ) * t>= p) ans = mid ,l = mid + 1;
        else r = mid - 1;
    }
    std::cout << ans - 1 << endl;
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

C Insert and Equalize

题目大意

给你一个整数数组 a[1],a[2],...,a[n]所有元素都是不同的。

首先，要求你在这个数组中再插入一个整数 a[n+1]，a[n+1] 不应等于 a1,a2,...,an。

然后，你必须使数组中的所有元素相等。一开始，你选择一个==正整数==x(x\>0 )在一次操作中，你将 x 恰好加到数组的一个元素上。 ==注意，所有操作中 x 都是相同的==。在你选择 a[n+1]和 x 之后，使所有元素相等的最小操作次数是多少？

解题思路

假设数组a 中有元素x, y, z (三者互不相等, 其中 z 最大) , 那么我们就需要找到一个数w,使得 x+k1*w=z, y+k2*w=z 显然就可以看出一个性质w=gcd(abs(x-y), abs(y-z)) 就这样我们找到了题目中的x,接下来, 我们需要找插入的a[n+1] 令 ma=max(a),因为元素互不相等, 我们就需要找插入比ma大k*w 和比ma小k*w的两个数, 分别重新找出最大值, 并计算所有元素加到ma的次数输出两种情况下最小的次数.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n;
    std::cin >> n;
    std::vector<int> a, b;
    std::map<int , int> mp;
    for(int i = 0 ; i < n ; i ++){
        int x;
        std::cin >> x,a.push_back(x), b.push_back(x), mp[a[i]] = 1;
    }

    int w = unique(a.begin (), a.end()) - a.begin ();
    if(w == 1){
        std::cout << 1 << endl;
        return ;
    }
    int o = abs(a[1] - a[0]);
    for(int i = 2 ; i < n ; i ++)
        o = std::__gcd(abs(a[i] - a[i - 1]), o);
    // std::cout << o << endl;
    int cnt = 0;
    int k1 = *std::max_element (a.begin (), a.end ());
    while(true){
        cnt ++;
        if(mp[k1 - cnt * o] != 1){
            a.push_back (k1 - cnt * o);
            break;
        }
    }
    k1 = *std::max_element (a.begin (), a.end ());
    int ans1 = 0, ans2 = 0;
    for(int i = 0 ; i < (int)a.size(); i ++)
        ans1 += abs(a[i] - k1) / o;
    cnt = 0;
    int k2 = *std::max_element (b.begin (), b.end ());
    while(true){
        cnt ++;
        if(mp[k2 + cnt * o] != 1){
            b.push_back (k2 + cnt * o);
            break;
        }
    }
    k2 = *std::max_element (b.begin (), b.end ());
    for(int i = 0 ; i < (int)b.size(); i ++)
        ans2 += abs(a[i] - k2) / o;
    std::cout << std::min(ans1, ans2) << endl;

}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

D Robot Queries

题目描述

给一个长度为n 的字符串和q次询问, 机器人开始在(0,0) 机器人可以执行四条指令：

U-- 从点(x,y) 移动到 (x,y+1) ；

D-- 从点(x,y) 移动到 (x,y−1)；

L--从点 (x,y) 移动到 (x−1,y)；

R--从点 (x,y) 移动到 (x+1,y)。每次询问四个数x, y, l, r , 判断机器人是否访问过点(x, y),但字符串l 到 r 的字串是相反的.

代码

(TLE 13)

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    int n, q;
    std::cin >> n >> q;
    std::string s;
    std::cin >> s;
    s = " " + s;
    while(q --){
        int x = 0, y = 0, N, M, l, r;
        std::cin >> N >> M >> l >> r;
        std::string str(s);
        bool f = false;
        reverse (str.begin() + l, str.begin () + r + 1);
        // std::cout << str << endl;
        for(int i = 1; i < (int) str.size() ;i ++){
            if(x == N && y == M){
                std::cout << "YES" << endl;
                f = true;
                break;
            }
            if(str[i] == 'U')y ++;
            else if(str[i] == 'D') y --;
            else if(str[i] == 'L') x --;
            else x ++;
            if(x == N && y == M){
                std::cout << "YES" << endl;
                f = true;
                break;
            }
            // std::cout << x << " " << y << endl;
        }
        if(!f)
            std::cout << "NO" << endl;
    }
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    // std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

Codeforces Round 922 Div2

Thu, 08 Aug 2024 23:39:47 GMT

A Brick Wall

题目描述

砖块大小为1 * k,砖块可以水平和竖直放置, 现在,我们用这样的砖块砌一堵n * m的墙, 墙的稳定性为水平砖块数与垂直砖块数之差. 问:最大稳定性是多少

解题思路

为了使墙的稳定性最高,我们可以让所有的砖块水平放置,且砖块的大小为1*2,这样墙的稳定为$n \times (m / 2)$

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e16 + 50, MOD = 10007;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::cout << n * (m / 2) << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Minimize Inversions

题目描述

长度为n的数组a和b,由于讨厌倒置($a_{i}<a_{j},i >j$) 我们将调整顺序即:交换$a_i,a_j和b_i,b_j$ 以使倒置的数较少

解题思路

我们可以直接对一个数组排序即可,这样就可以使一个数组没有倒置,使答案最小化.

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]const int INF = 1e17 + 50;
[[maybe_unused]] typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    std::vector<pii> a(n);
    for(int i = 0; i < n; i ++)
        std::cin >> a[i].first;
    for(int i = 0; i < n; i ++)
        std::cin >> a[i].second;
    std::sort(a.begin(), a.end());
    for(int i = 0 ; i < n ; i ++)
        std::cout << a[i].first << " \n"[i == n - 1];
    for(int i = 0 ; i < n ; i ++)
        std::cout << a[i].second << " \n"[i == n - 1];
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Codeforces Round 916 Div3

Thu, 08 Aug 2024 23:38:48 GMT

A Problemsolving Log

题目描述

给一个整数n,字符串s,字符串中s[i]表示第i分钟解决第s[i]题. 问题A需要1分钟解决,问题B需要2分钟解决,以此类推.

问:可以解决多少题?

解题思路

遍历字符串,统计问题A -- Z用了多少时间解决. 最后在遍历数组,判断问题A -- Z是否满足解决时间.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    std::vector<int> a(26, 0);
    for (auto i: s)
        a[i - 'A']++;
    int cnt = 0;
    for (int i = 0; i < 26; i++)
        if (a[i] >= i + 1)
            cnt++;
    std::cout << cnt << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Preparing for the Contest

题目描述

给两个整数n, k (0 <= k <= n - 1) 问:打印出a[i + 1] > a[i](0<= i < n - 1)的次数等于k的方案.

解题思路

打个比方: n == 6, k == 2, 我们有这样一个数组[1, 2, 3, 4, 5, 6] 现在将数组重新排序,排序后要满足a[i + 1] > a[i](0<= i < n - 1)的次数等于k. 我们可以将数组后面k + 1个数放在前面,即[4, 5, 6, 1, 2, 3] 多举几个例子就可以发现上述规律.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n, 0ll);
    std::iota(a.begin(), a.end(), 1ll);
    for (int i = n - k - 1; i < n; i++)
        std::cout << a[i] << " ";
    for (int i = n - k - 2; i >= 0; i--)
        std::cout << a[i] << " ";
    std::cout << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Quests

题目描述

有n个任务,每个任务完成后对应两个值a[i]和b[i],首次完成第i个任务时,可获得a[i]分,若此后再完成该任务可获得b[i]分问:现在,可以完成k个任务,可获得的最大分数是多少?

解题思路

枚举走到哪一个位置，然后记录前面的b[i]最大值

代码


#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]typedef std::pair<int, int> pii;

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n + 1, 0ll), b(n + 1, 0ll);
    for (int i = 0; i < n; i++)
        std::cin >> a[i];
    for (int i = 0; i < n; i++)
        std::cin >> b[i];
    int s = 0, ma = 0, ans = 0;
    for (int i = 0; i < std::min(n, k); i++) {
        s += a[i];
        ma = std::max(ma, b[i]);
        ans = std::max(ans, s + (k - i - 1) * ma);
    }
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

D Three Activities

题目描述

给出一个n,并且给出这n天参加三项活动的人数a[i], b[i], c[i].

问:最多能有多少人参加这三项活动,并且参加这三项不在同一天.

解题思路

我们只需要模拟一下,但是这个模拟需要优化一下.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]]typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n, 0ll), b(n, 0ll), c(n, 0ll);
    for (int i = 0; i < n; i++)std::cin >> a[i];
    for (int i = 0; i < n; i++)std::cin >> b[i];
    for (int i = 0; i < n; i++)std::cin >> c[i];
    std::vector<int> x(n, 0ll);
    std::iota(x.begin(), x.end(), 0ll);
    auto y = x, z = x;
    std::sort(x.begin(), x.end(), [&](int aa, int bb) { return a[aa] > a[bb]; });
    std::sort(y.begin(), y.end(), [&](int aa, int bb) { return b[aa] > b[bb]; });
    std::sort(z.begin(), z.end(), [&](int aa, int bb) { return c[aa] > c[bb]; });
    int w = std::min({n, 100ll}), ans = 0ll;
    for (int i = 0; i < w; i++)
        for (int j = 0; j < w; j++)
            for (int k = 0; k < w; k++)
                if (x[i] != y[j] && x[i] != z[k] && y[j] != z[k])
                    ans = std::max(a[x[i]] + b[y[j]] + c[z[k]], ans);
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Codeforces Round 914 Div2

Thu, 08 Aug 2024 23:36:20 GMT

A Forked!

题目大意

给定王后和国王的位置, 马可以先朝一个方向走a步,再朝另一个方向走b步问:马有多少个位置可以同时走到皇后和国王

解题思路

就无脑遍历一下马能走到国王和皇后的位置然后再判断下有没有相同的位置

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 1e9 + 50;

int dx[4] = {-1, 1, -1, 1}, dy[4] = {-1, -1, 1, 1};

void solve() {
    int x1, x2, y1, y2, a, b;
    std::cin >> a >> b >> x1 >> y1 >> x2 >> y2;
    std::set<std::pair<int ,int>> s1, s2;
    for(int i = 0 ; i < 4 ; i++){
        s1.insert({x1+dx[i]*a, y1+dy[i]*b});
        s1.insert({x1+dx[i]*b, y1+dy[i]*a});
        s2.insert({x2+dx[i]*a, y2+dy[i]*b});
        s2.insert({x2+dx[i]*b, y2+dy[i]*a});
    }
    int cnt = 0;
    for(auto i : s1){
        if(s2.find (i) != s2.end())
            cnt ++;
    }
    std::cout << cnt << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Collecting Game

题目大意

给一个数组a,对于每一个元素,我们都会有一个初始值w = a[i] (0 <= i < n)只要w大于或等于数组中的某个元素,w = w + a[k]并且就会把这个数删除掉.

问: 对于每个元素,至多可以删除多少元素?

解题思路

由于需要最大化删除个数,我们可以先对数组升序排序,这样对于i(0 <= i < n) 就可以将0 ~ i-1的所有数删除掉,然后再考虑后面的.

就这样模拟下过程就完事儿了.

代码

(提交的一次TLE的代码)

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    pii a[n];
    for (int i = 0; i < n; i++)
        std::cin >> a[i].first, a[i].second = i;
    std::sort(a, a + n);
    std::vector<int> s(n, 0ll);
    for (int i = 0; i < n; i++) {
        if (i == 0)
            s[i] = a[i].first;
        else
            s[i] = s[i - 1] + a[i].first;
    }
    std::vector<int> ans(n, 0ll);
    for (int i = 0; i < n; i++) {
        int t = s[i], j = i + 1;
        while (j < n && t >= a[j].first)
            t += a[j++].first;
        ans[i] = j - 1;
    }
    for (int i = 0; i < n; i++)
        a[i].first = ans[i];
    std::sort(a, a + n, [&](pii aa, pii bb) {
        return aa.second < bb.second;
    });
    for(int i = 0 ; i < n ; i ++){
        std::cout << a[i].first << " ";
    }
    std::cout << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

(AC代码)

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
[[maybe_unused]] const int INF = 1e9 + 50;

typedef std::pair<int, int> pii;

void solve() {
    int n;
    std::cin >> n;
    pii a[n + 1];
    for (int i = 0; i < n; i++) {
        std::cin >> a[i].first;
        a[i].second = i;
    }
    std::sort(a, a + n);
    std::vector<int> b(n, 0ll), c(n, 0ll), d(n, 0ll);
    for (int i = 0; i < n; i++) {
        b[i] = a[i].first;
        if (i == 0)
            c[i] = b[i];
        else
            c[i] = c[i + 1] + b[i];
    }
    for (int i = 0; i < n; i++) {
        int t = c[i];
        int k = t;
        while (true) {
            int w = std::upper_bound(b.begin(), b.end(), t) - b.begin();
            if (w == n) {
                d[a[i].second] = n - 1;
                break;
            } else {
                if (c[w - 1] == k) {
                    d[a[i].second] = w - 1;
                    break;
                } else {
                    k = c[w - 1];
                    t = c[w - 1];
                }
            }
        }
    }

    for (int i = 0; i < n; i++)
        std::cout << d[i] << " ";
    std::cout << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Array Game

题目大意

给一个数组a,有k次操作,每次操作选一个(i, j) (0 <= i < j < n) ,将|a[j] - a[i]|放在数组的足以后方.

问:k次操作后得到的数组最小的数为多少?

解题思路

首先,可以考虑到k>=3时,我们可以先选两次相同的(i, j),然后再选新加入的这两个,这样就可以得到0了`

然后再是k == 1时, 我们想让答案最小化,我们只能先将数组排序,然后再找相邻的两个的的差值,再到最小值后,答案还不是最优值, 所以还要与原数组最小值比较.

最后, 再是 k == 2时, 题目中明确告诉n^2 < 4e6,这就是让我们暴力循环,我们可以先将k == 1时的最小值记录下来,然后再暴力n^2跑一遍数组,再与之前的比较一下,最后输出答案.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a;
    for (int i = 0; i < n; i++) {
        int x;
        std::cin >> x;
        a.push_back(x);
    }
    if (k >= 3) {
        std::cout << 0 << endl;
        return;
    }
    std::sort(a.begin(), a.end());
    auto calc = [&]() {//相当于处理了一次
        std::sort(a.begin(), a.end());
        int ans = a[0];
        for (int i = 1; i < (int) a.size(); i++) {
            ans = std::min(ans, a[i] - a[i - 1]);
        }
        return ans;
    };

    int ans = calc();
    if (k == 2) {
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int w = a[j] - a[i];
                int p = std::lower_bound(a.begin(), a.end(), w) - a.begin();
                if (p != n - 1)
                    ans = std::min(ans, a[p] - w);
                if (p != 0)
                    ans = std::min(ans, w - a[p - 1]);
            }
        }
    }
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Codeforces Round 913 Div3

Wed, 07 Aug 2024 17:11:13 GMT

A Rook

题目大意

给一个国际象棋棋盘,有t次询问,每次询问给定一个棋子坐标s 例如 d4.

问: 输出这个棋子上下左右四个方向的坐标

解题思路

两个for循环暴力求解

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve(){
    std::string s;
    std::cin >> s;
    for(int i = 1; i <= 8 ; i ++)//枚举当前列
        if(i != s[1] - '0')
            std::cout << s[0] << i << endl;

    for(int i = 0; i < 8 ; i ++)//枚举当前行
        if(i + 'a' != s[0])
            std::cout << (char)(i + 'a') << s[1] << endl;
}

signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

B YetnotherrokenKeoard

题目大意

有t次询问,每次询问会给定一个字符串s, 我们要敲击键盘拼接出这个字符串,但是存在一些规则:

每次敲击b就会将位于这个b左边存在小写字母,那么就将距离b最近的一个删除,

同理,当敲击大写字母时,就会删除这个B左边最近的一个大写字母.

问: 最后会组成一个怎样的字符串.

解题思路

这个题由于数据量比较大,就不要尝试双重循环去删除字符了我们可以发现一个规律,我们只删除当前字符前大小写形式相同的字符,并且只能删除一次,而且是删除距离最近的, 这就有点像堆栈(后进先出),那我们就可以用栈来模拟这个过程我们可以给每个字符做个标记,即创建一个和字符串大小相同的bool数组若为b或B或被删除的字符标记为false,否则为true

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve() {
    std::string s;
    std::cin >> s;
    std::vector<bool> f((int) s.size(), true);
    std::stack<int> a, b;
    for (int i = 0; i < (int) s.size(); i++) {
        if (s[i] == 'b' || s[i] == 'B') {
            f[i] = false;
            if (isupper(s[i]) && !b.empty()){
                f[b.top()] = false;
                b.pop();
            }
            else if(islower(s[i]) && !a.empty()){
                f[a.top()] = false;
                a.pop();
            }
        } else {
            if(islower(s[i]))
                a.push(i);
            else
                b.push(i);
        }
    }
    while (!a.empty())
        a.pop();
    while (!b.empty())
        b.pop();
    for (int i = 0; i < (int) s.size(); i++)
        if (f[i])
            std::cout << s[i];
    std::cout << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Removal of Unattractive Pairs

题目描述

有t次询问,每次询问给出一个长度为n的字符串,字符串两个字符不同则可以删除这两个字符问: 字符串最短有多长.

解题思路

用手玩玩就ok

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve() {
    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    std::vector<int> a(26, 0ll);
    for(auto i : s)
        a[i - 'a'] ++;
    int ma = *std::max_element(a.begin (), a.end());
    if(ma * 2 <= n)
        std::cout << n % 2 << endl;
    else
        std::cout << n - 2 * (n - ma) << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

D Jumping Through Segments

题目描述

有t次询问,每次询问会给n个L, R,其中第 i 段从坐标为L[i]的点开始,到坐标为R[i]的点结束。玩家从坐标为 0 的点开始通关。在一次移动中，他们可以移动到距离不超过 k 的任意一点。在第i次移动后，玩家必须落在第i段之内，即在坐标x处，使得 L[i]≤x≤R[i]。这意味着,每次移动都必须在L[i] ~ R[i] 如果玩家按照上述规则到达了第 n个段落，那么这一关就算完成了。为了不希望这个关卡太简单，所以要求确定可以完成这个关卡的最小整数k。

解题思路

核心思想就是二分答案.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int INF = 0x3f3f3f3f;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> L(n, 0ll), R(n, 0ll);
    for(int i = 0 ; i < n ; i ++)
        std::cin >> L[i] >> R[i];
    int l = 0, r = 1e16 + 50;
    auto check = [&] (int x){
        int ma = 0, mi = 0;
        for(int i = 0 ; i < n ; i ++){
            ma = std::min (ma + x, INF);
            mi = std::max (mi - x, 0ll);
            mi = std::max(mi, L[i]);
            ma = std::min(ma, R[i]);
            if(mi > ma)
                return false;
        }
        return true;
    };
    while(l < r){
        int mid = (l + r) >> 1;
        if(check (mid)) r = mid;
        else l = mid + 1;
    }
    std::cout << r << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Codeforces Round 912 Div2

Wed, 07 Aug 2024 17:07:28 GMT

A Halloumi Boxes

题目大意

给定一个数组A,我们可以对数组惊醒多次操作,操作如下: 我们可以将数组中的某一段倒置,但是长度不能超过K,例如:反转子数组意味着选择两个索引i和j(其中 1 <= i <= j <= n ) 并将数组 $a_1,a_2,\cdots,a_n$ 改为 $a_1,a_2,\cdots,a_{i−1},a_{j},a_{j−1},\cdots,a_{i},a_{j+1},…,a_{n-1},a_n \quad (j − i + 1 \le k )$ 。

分析

由于可以操作多次,那么我们可以判断下k是否为1:

若k = 1时, 我们只能反转一个元素,显然是无效的, 我们就只需要判断数组是否为有序

若k > 1时,显然是可行的

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve () {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n, 0), b(n, 0);
    for(int i = 0 ; i < n ; i ++)
        std::cin >> a[i], b[i] = a[i];

    std::sort(b.begin (), b.end ());
    bool f = true;
    for(int i = 0 ; i < n ; i ++){
        if(a[i] != b[i]){
            f = false;
            break;
        }
    }
    if(f)
        std::cout << "YES" << endl;
    else {
        if(k > 1)
            std::cout << "YES" << endl;
        else
            std::cout << "NO" << endl;
    }
}


signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

B StORage room

题目大意

给定一个数n,和一个n*n的数组M,数组$M_{i,j}$ 表示为:$M_{i,j} = \begin{cases} a_i|a_j,(i \not= j)\\ 0, (i == j)\end{cases}(M_{i,j} < 2 ^{30})$

让我们判断是否存在这样的一个数组a满足上式,若存在输出YES和数组a 否则输出NO

分析

现在我有两个数x, y,如果我将这两个数进行或运算后(w = x | y), 在二进制状态下x和y在某一位上有一个为1,则该位为1通过这个我们可以发现在$M_i$ 中,$M_{i,0} = a_i | a_0, M_{i,1} = a_i | a_1, ........, M_{i,n - 1} = a_i | a_{n - 1}$ , 我们可以通过与运算将$a_i$ 计算出来, 但是在运算时我们需要排除$M_{i,j}(i==j)$; 在计算完后我们可以遍历一次M数组,判断$M_{i,j}=a_i|a_j(i \not= j)$

参考代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve () {
    int n;
    std::cin >> n;
    std::vector<int> a(n, 0);
    std::vector<std::vector<int> > m(n, std::vector<int> (n, 0));
    for(int i = 0 ; i < n ; i ++){
        int x = -1;
        for(int j = 0;j < n;j ++){
            std::cin >> m[i][j];
            if(i != j){
                if(x == -1)
                    x = m[i][j];
                x &= m[i][j];
            }
        }
        a[i] = x;
    }
    if(n == 1){//特殊情况,可任意输出一个数
        std::cout << "YES" << endl << 1 << endl;
        return ;
    }
    auto check = [&] (){
        for(int i = 0 ; i < n ; i ++){
            for(int j = 0 ; j < n ; j ++){
                int x = a[i] | a[j];
                if(m[i][j] != x && i != j){
                    return false;
                }
            }
        }
        return true;
    };
    if(check()){
        std::cout << "YES" << endl;
        for(int i = 0 ; i < n ; i ++)
            std::cout << a[i] << " ";
        std::cout << endl;
    }
    else
        std::cout << "NO" <<endl;
}


signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

C Theofanis' Nightmare(贪心)

题目大意

给定一个数组a,大小为n,现在将数组a分割成几个非空子数组,并且保证每个元素只在一个一个子数组中,例如，数组 [1,−3,7,−6,2,5]可以划分为 [1][−3,7][−6,2][5]。这种分割的值等于$\sum_{i=1}^k i*sum_i$ ，其中k是我们将数组分割成的子数组的个数，$sum_i$ 是第i个子数组的和。这个数组的值为$[1][−3,7][−6,2][5]=1\times 1+2\times (−3+7)+3\times (−6+2)+4\times5=17$ 现在让我们求分割的最大值为多少?

分析

先考虑每个子段的数字贡献，i* sum_i也可以转化为该子段中每个数字被加上了i次。那么就可以把乘法转化为加法。

然后考虑怎么划分子段最优，如果从前往后考虑，很难判断是否该将当前数字划分为一个新子段的起点。因此，需要从后往前遍历，统计i∼n之间的数字总和，为了使答案尽可能大，那么只要当前数字总和大于等于0，就可以将当前位置划分给一个新的子段起点。

此时，划分出一个新的起点后，那么后面所有的数字均需要再被加上一次，不难发现，此时要加上的就是维护的数字总和。

由于第一个元素也可能被划分到一个新的子段中，为了避免重复计算，当遍历到第一个元素时，必须将当前元素视为子段起点，加上维护的数字总和。

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve () {
    int n;
    std::cin >> n;
    std::vector<int> a(n, 0);
    for(int i = 0 ; i < n ; i ++)
        std::cin >> a[i];
    int ans = 0, w = 0;
    for(int i = n - 1; i >= 0 ; i --){
        w += a[i];
        if(i == 0 || w > 0)
            ans += w;
    }
    std::cout << ans << endl;
}


signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy = 1;
    std::cin >> Lazy_boy;
    while (Lazy_boy--)
        solve ();
    return 0;
}

#include <bits/stdc++.h>

#define int long long
#define endl '\n'

void solve () {
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1, 0ll), s(n + 1, 0ll);
    for(int i = 1 ; i <= n ; i ++)
        std::cin >> a[i], s[i] = s[i - 1] + a[i];
    int ans = 0, w = 0;
    for(int i = 1; i <= n ; i ++){
        if(i == 1 || s[n] - s[i - 1] >= 0)
            w ++;
        ans += w * a[i];
    }
    std::cout << ans << endl;
}


signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve ();
    return 0;
}

D1 Maximum And Queries (easy version)

题目大意

给出一个长度为n的数组a，并进行q次询问，每次询问为：你可以进行k次操作，每次从数组a中选择一个元素，让这个元素 + 1。问：经过q次操作后,$a_1,a_2,.....,a_n$的与的最大值是多少注：每次询问都是独立的，不会保留前面询问的操作结果。

分析

由于每次询问都是独立的，那么修改不能在原数组上进行，需要将原数组元素复制到其他数组中再进行操作。题目数据规定了$n\times q≤10^5$，那么可以认为最大的数据就是对长度为$10^5$的数组进行一次询问。由于给出的$k≤10^{18}$ ，那么当数组中只有一个元素时，最大可能的结果为$10^{18}+10^6≈2^{60}$ ，因此需要一个大于60的数组记录与运算后的结果每位二进制数是多少。对于每次询问，从二进制高位开始往低位进行遍历，每次检查当前剩余的k是否还能将数组中所有数的当前二进制位修改为1 如果可以，进行修改，并记录在答案数组中，如果不行，继续遍历更低的二进制位。结束修改后，将数组中记录的信息转化为十进制数即可。

本题数据较大，需要注意使用左移运算需要使用1ll将1转化为long long类型再进行运算，计算花费时也要考虑如果超过操作次数就该退出检查，避免数据溢出。

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
const int N = 1e5 + 5;

int a[N], b[N], ans[105];
int n, q;

int getCost(int x, int k) {
    int cost = 0;
    for (int j = 1; j <= n; j++) {
        if ((b[j] & (1ll << x)) == 0) {
            //使用位运算计算将b[j]的第x位二进制修改为1需要加上多少
            cost += (1ll << x) - ((1ll << (x + 1)) - 1ll & b[j]);
        }
        if (cost > k) return cost; //超过k就返回，避免数据溢出
    }
    return cost;
}

void solve() {
    std::cin >> n >> q;
    for(int i = 1; i <= n ; i ++)
        std::cin >> a[i];
    while(q --){
        int k;
        std::cin >> k;
        memset(ans, 0, sizeof(ans));
        for (int i = 1; i <= n; i++)
            b[i] = a[i];
        for (int i = 60; i >= 0; i--) {//检查第i位结果与运算的结果是否可能为1
            int cost = getCost(i, k);
            if (cost <= k) {//花费在操作次数范围内
                ans[i] = 1;//与运算结果可以为1
                k -= cost;
                for (int j = 1; j <= n; j++) {
                    if ((b[j] & (1ll << i)) == 0) {
                        //通过或运算将2^i位修改为1，再通过与运算将后面数字清0
                        b[j] = ((b[j] | (1ll << i)) & (1ll << i));
                    }
                }
            }
        }
        int res = 0;
        for (int i = 0; i <= 60; i++)
            res |= (ans[i] << i);//这里ans[i]如果不是long long类型也会发生溢出
        std::cout << res << endl;
    }
}


signed main () {
    std::ios::sync_with_stdio (false);
    std::cin.tie (nullptr), std::cout.tie (nullptr);
    int Lazy_boy = 1;
    // std::cin >> Lazy_boy;
    while (Lazy_boy--)
        solve ();
    return 0;
}

Hello2024

Mon, 01 Jan 2024 23:46:17 GMT

A Wallet Exchange

题目大意

Alice有a个硬币,Bob有b个硬币,双方轮流进行以下操作: 1.与对方交换硬币,或者保留现有硬币. 2.取出一个硬币无法进行操作的人判定为输,总是从Alice开始操作问:哪位获得胜利

解题思路

我们可以把游戏看作是轮流取硬币,取得最后一个硬币的为胜利那么我们就可以直接判断a+b奇偶性就可以得出答案.

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int a, b;
    std::cin >> a >> b;
    std::cout << ((a + b) % 2 ? "Alice" : "Bob") << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Plus-Minus Split

题目大意

略

解题思路

简单看下样例就猜出来是+与-的差值的绝对值

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int n;
    std::string s;
    std::cin >> n >> s;
    int cnt1 = 0;
    for (auto i: s)
        cnt1 += (i == '+');
    std::cout << abs((n - cnt1) - cnt1) << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Grouping Increases

题目大意

解题思路

贪心

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int n, ans = 0;
    std::cin >> n;
    std::vector<int> a(n, 0ll);
    for (int i = 0; i < n; i++) std::cin >> a[i];
    std::vector<int> A, B;
    A.push_back(INF), B.push_back(INF);
    for (int i = 0; i < n; i++) {
        int x = A.back(), y = B.back();
        if (x < y) {
            if (a[i] <= x)
                A.push_back(a[i]);
            else if (a[i] <= y)
                B.push_back(a[i]);
            else {
                A.push_back(a[i]);
                ans++;
            }
        } else {
            if (a[i] <= y)
                B.push_back(a[i]);
            else if (a[i] <= x)
                A.push_back(a[i]);
            else {
                B.push_back(a[i]);
                ans++;
            }
        }
    }
    std::cout << ans << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

Goodbye2023

Sun, 31 Dec 2023 23:44:55 GMT

A 2023

题目描述

给定 n个数，让我们判断是否能与 m个数相乘后可以得到 2023，并且将这些数输出出来

解题思路

我们只需要判断这些数能否被2023整除。

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int s = 2023;
    int n, m;
    std::cin >> n >> m;
    std::vector<int> a(n);
    for (int i = 0; i < n; i++) std::cin >> a[i];
    for (int i = 0; i < n; i++)
        if (s % a[i]) {
            std::cout << "NO" << endl;
            return;
        } else {
            s /= a[i];
        }
    std::cout << "YES" << endl;
    for (int i = 0; i < m - 1; i++)
        std::cout << 1 << " ";
    std::cout << s << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

B Two Divisors

题目描述

选择一个 (1 <= x <= 1e9) 的数。同时满足 1≤a<b<x 的条件。对于给定的数 a、b，你需要求出 x 的值。如果有整数 k，使得 x=y⋅k, 则数 y 是数 x 的除数。

解题思路

首先你得要知道，你需要这个值有a和b，那么是和lcm(a,b)是有关系的，默认a<b，然后其次你发现，lcm(a,b)如果和b一样的话，那么你的这个值，实际上他会选不到b，那么我们需要把这个值增加一些，并且不影响答案。那么这个增加的值实际上就是lcm(a,b)/a，首先这题有解，那么lcm(a,b)一定有a和b的因子，由于他们是最大的，所以我们需要乘一个小数，去使得能选到b，但是a和b仍然是最大两个，所以当你的lcm(a,b)不是b的时候，那么lcm(a,b)就是答案，否则，答案应该乘上一个小值，那么乘上什么值是正确的，首先我们要理解，肯定不能让a变成除了b以外的数字，那么就是乘上一个lcm(a,b)/a，乘上这个值之后，他们的因子没有出现新大数。

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int a, b;
    std::cin >> a >> b;
    if (b % a)
        std::cout << a * b / std::gcd(a, b) << endl;
    else
        std::cout << b * b / a << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}

C Training Before the Olympiad

题目描述

玛莎和奥丽雅马上就要参加一个重要的团队奥林匹克竞赛了。为此，玛莎建议和奥丽雅玩一个热身游戏：有一个大小为 n 的数组 a。马莎先走，然后大家轮流走。每一步都可以用下面的操作顺序来描述：如果数组的大小为 1，游戏结束。当前下棋的棋手选择两个不同的索引 i、j(1≤i,j≤|a|)，并执行以下操作--从数组中移除 ai 和 aj，并在数组中添加一个等于⌊ai+aj2⌋⋅2 的数字。换句话说，首先将 ai 和 aj 的和除以 2(向下舍入)，然后将结果乘以 2。玛莎的目标是最大化最终数字，而奥丽雅的目标是最小化最终数字。玛莎和奥丽雅决定在初始数组 a 的每个非空前缀上进行博弈，并请求您的帮助。对于每个 k(=1,2,...,n)，请回答下面的问题。让数组 a 的前 k 个元素出现在游戏中，索引分别为 1,2,...,k。在双方都下得最好的情况下，最后会剩下多少个元素？

解题思路

我们只需要注意到奇数加偶数会产生一个-1，那么我们就是要算怎么样计算这个值，我们发现，无论哪两个数字都会产生一个偶数，所以偶数是最后消去的，我们如果想要答案最大，那么一定是优先消除掉奇数，如果想要答案最小，一定是奇数和偶数组合，那么我们记录奇数和偶数的数量，在面对到奇数的时候，这个减去的多少个-1，我们可以算出他的过程，注意对于只有一个数字的情况要特判。

代码

#include <bits/stdc++.h>

#define int long long
#define endl '\n'
#define fix(n) std::fixed << std::setprecision(n)
[[maybe_unused]]typedef std::pair<int, int> pii;
[[maybe_unused]]const int INF = 1e18 + 50;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; i++) std::cin >> a[i];
    int S = 0, C = 0;
    for (int i = 0; i < n; i++) {
        S += a[i], C += a[i] & 1;
        if (i == 0)
            std::cout << a[i] << " \n"[i == n - 1];
        else
            std::cout << S - C / 3 - (C % 3 == 1) << " \n"[i == n - 1];
    }
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    int Lazy_boy_ = 1;
    std::cin >> Lazy_boy_;
    while (Lazy_boy_--)
        solve();
    return 0;
}