线段树维护2X2矩阵

樱花山下

于 2024-10-04 14:47:16 发布

阅读量18

点赞数 2

文章标签：矩阵 java 算法蓝桥杯数据结构

本文链接：https://blog.csdn.net/2301_79494744/article/details/142703162

版权

import java.util.Scanner;

public class Main {
    static long[][][] segmentTree;
    static int n;
    static int mod=998244353;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        int m=scanner.nextInt();
        long[][][] nums=new long[n][2][2];
        for (int i = 0; i <n; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    nums[i][j][k]=scanner.nextInt()%mod;
                }
            }
        }
        NumArray(nums);
        for (int j = 0; j < m; j++) {
            int c= scanner.nextInt();
            switch (c){
                case 1:
                    int pos= scanner.nextInt()-1;
                    long[][] val=new long[2][2];
                    for (int i = 0; i < 2; i++) {
                        for (int k = 0; k < 2; k++) {
                            val[i][k]= scanner.nextInt();
                        }
                    }
                    update(pos, val);
                    break;
                case 2:
                    long[][] ans=sumRange(scanner.nextInt()-1,scanner.nextInt()-1);
                    for (int i = 0; i < 2; i++) {
                        for (int k = 0; k < 2; k++) {
                            System.out.print(ans[i][k]%mod+" ");
                        }
                    }
                    break;
            }
        }
        scanner.close();
    }

    public static void NumArray(long[][][] nums) {
        n = nums.length;
        segmentTree = new long[nums.length * 4][2][2];
        build(0, 0, n-1, nums);
    }

    public static void update(int index, long[][] val) {
        change(index,val,0,0,n-1);
    }
    public static long[][]  sumRange(int left,int right){
        return range(left,right,0,0,n-1);
    }

    private static long[][] range(int left, int right, int node, int l, int r) {
        if(left==l&&right==r){
            return segmentTree[node];
        }
        int mid=(l+r)/2;
        if(right<=mid){
            return range(left,right,node*2+1,l,mid);
        } else if (left>mid) {
            return range(left,right,node*2+2,mid+1,r);
        }else {
            return multip(range(left,mid,node*2+1,l,mid),range(mid+1,right,node*2+2,mid+1,r));
        }
    }


    public static void build(int node, int l, int r, long[][][] nums) {
        if (r == l) {
            segmentTree[node] = nums[r];
            return;
        }
        int mid = (r + l) / 2;
        build(node * 2 + 1,l, mid, nums);
        build(node * 2 + 2, mid + 1, r, nums);
        segmentTree[node] = multip(segmentTree[node * 2 + 1],segmentTree[node * 2 + 2]);
    }

    public static void change(int index, long[][] val, int node, int l, int r) {
        if (l == r) {
            segmentTree[node] = val;
            return;
        }
        int mid = (r + l) / 2;
        if (index <= mid) {
            change(index, val, node * 2 + 1, l, mid);
        } else {
            change(index, val, node * 2 + 2, mid + 1, r);
        }
        segmentTree[node] = multip(segmentTree[node * 2 + 1],segmentTree[node * 2 + 2]);
    }
    public static long[][] multip(long[][] A,long[][] B){
        long[][] ans=new long[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    ans[i][j]+=(A[i][k]*B[k][j]);
                }
            }
        }
        return ans;
    }

}