西工大数据结构理论NOJ第四部分，特殊矩阵的存储-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_65892509/article/details/131333267

#include <stdio.h>
#include <stdlib.h>
typedef struct node {
    int data;
    struct node* next;
}node;
typedef struct Queue
{
    struct node* rear;
}Queue;
Queue* create()
{
    Queue* qptr = (Queue*)malloc(sizeof(Queue));
    if (!qptr)
    {
        printf("create error!\n");
    }
    else
    {
        qptr->rear = NULL;
    }
    return qptr;
}
void push(Queue* qptr, int e)
{
    node* p = (node*)malloc(sizeof(node));
    if (!p)
    {
        printf("push error");
        return;
    }
    p->data = e;
    p->next = NULL;
    if (qptr->rear == NULL)
    {
        qptr->rear = p;
        qptr->rear->next = p;
    }
    else
    {
        p->next = qptr->rear->next;
        qptr->rear->next = p;
        qptr->rear = p;
    }
}
void pop(Queue* qptr)
{
    if (qptr->rear == NULL)
    {
        return;
    }
    node* p = qptr->rear->next;//p指向队头节点
    qptr->rear->next = p->next;//队尾节点指针域指向对头结点的下一个
    free(p);
}
void cal(Queue* qptr, int max, int k)
{
    for (int i = k; i > 1; i--) {
        push(qptr, 0);
    }
    push(qptr, 1);
    node* p = qptr->rear->next;
    while (p->next->data == 0)
        p = p->next;
    node* q = p->next;
    int x = p->data + q->data;
    while (1)
    {
        if (x > max)
            break;
        push(qptr, x);
        p = p->next;
        q = q->next;
        x = p->data + q->data;
        pop(qptr);
    }
}
void display(Queue* qptr)
{
    node* p;
    p = qptr->rear->next;
    while (p != qptr->rear) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("%d ", p->data);
}
void destroy(Queue* qptr)
{
    if (qptr->rear->next == NULL)
        return;
    node* p = qptr->rear->next;
    qptr->rear->next = NULL;
    while (p != qptr->rear)
    {
        qptr->rear->next = p;
        p = p->next;
        free(qptr->rear->next);
    }
    free(qptr->rear);
}
int main()
{
    Queue* qptr = create();//创建空队列
    int n,e,k;
    scanf("%d%d", &n,&k);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &e);
        push(qptr, e);
    }
    for (int i = 0; i < k; i++)
        qptr->rear = qptr->rear->next;
    display(qptr);
    destroy(qptr);
    return 0;
}

#include<iostream>
using namespace std;
#define MAXSIZE 100
typedef struct triple {
	int i=0, j=0, e=0;
}triple;
typedef struct matrix {
	triple data[MAXSIZE];
	int mu=0, nu=0, tu=0;
};
void initmatrix(matrix* A,int n)
{
	A->tu = n;
	for (int i = 0; i < n; i++)
	{
		cin >> A->data[i].i >> A->data[i].j >> A->data[i].e;
		if (A->data[i].i > A->mu)//行数、列数均为输入的三元组的行列的最大值
			A->mu = A->data[i].i;
		if(A->data[i].j > A->nu)
			A->nu = A->data[i].j;
	}
}
void addmatrix(matrix* A,matrix* B, matrix* C)
{
	int k=0;
	int i = 0, j = 0;
	while (i < A->tu && j < B->tu)
	{
		if (A->data[i].i < B->data[j].i)
		{
			C->data[k] = A->data[i];
			k++;
			i++;
		}
		else if ((A->data[i].i > B->data[j].i) || (A->data[i].j > B->data[j].j))
		{
			C->data[k] = B->data[j];
			k++;
			j++;
		}
		else if(A->data[i].j == B->data[j].j)
		{
			if ((C->data[k].e = A->data[i].e + B->data[j].e) != 0)
			{
				C->data[k].i = A->data[i].i;
				C->data[k].j = A->data[i].j;
				C->data[k].e = A->data[i].e + B->data[j].e;
				k++;
			}
			i++;
			j++;
		}
		else
		{
			C->data[k] = A->data[i];
			k++;
			i++;
		}
	}
	while(i<A->tu)
	{
		C->data[k] = A->data[i];
		k++;
		i++;
	}
	while(j<B->tu)
	{
		C->data[k] = B->data[j];
		k++;
		j++;
	}
	C->tu = k;
	C->mu = A->mu;
	C->nu = A->nu;
}
void print(matrix* M)
{
	int i, j;
	for (i = 0; i < M->tu; i++)
	{
		cout << M->data[i].i <<" " << M->data[i].j <<" " << M->data[i].e << endl;
	}
	cout << endl;
}
int main()
{
	matrix A, B,C;
	int m, n;
	cin >> m >> n;
	initmatrix(&A, m);
	initmatrix(&B, n);
	addmatrix(&A, &B, &C);
	print(&C);
	return 0;
}

#include<iostream>
using namespace std;
typedef struct crosslinkNode
{
    int i, j, data;
    crosslinkNode* right, * down;
}node, * pnode;
typedef struct crosslink
{
    pnode* r, * c;
    int mu, nu, tu;
}link;
void create(link& A, int m, int n, int t)//创建空的十字链表
{
    A.r = (pnode*)malloc((m + 1) * sizeof(node));
    A.c = (pnode*)malloc((n + 1) * sizeof(node));
    A.mu = m;
    A.nu = n;
    A.tu = t;
    for (int i = 0; i <= m; i++)
        A.r[i] = NULL;
    for (int j = 0; j <= n; j++)
        A.c[j] = NULL;
}
void insert(link& A, int m, int n, int t)
{
    node* s = (node*)malloc(sizeof(node));
    s->right = NULL;
    s->down = NULL;
    if (!s)
        return;
    s->i = m;
    s->j = n;
    s->data = t;
    if (A.r[m] == NULL)
    {
        A.r[m] = s;
    }
    else
    {
        node* p = A.r[m];
        while (p->right != NULL && p->right->j < n)
            p = p->right;
        s->right = p->right;
        p->right = s;
    }
    if (A.c[n] == NULL)
        A.c[n] = s;
    else
    {
        node* p = A.c[n];
        while (p->down != NULL && p->i < m)
            p = p->down;
        s->down = p->down;
        p->down = s;
    }
}
void addmatrix(link& A, link& B, link& C)
{
    for (int i = 1; i <= A.mu; i++)
    {
        node* pb = B.r[i];
        node* pa = A.r[i];
        while (pa && pb)
        {
            if (pa->j == pb->j)
            {
                if ((pa->data + pb->data) != 0)
                {
                    insert(C, pa->i, pa->j, pa->data + pb->data);
                    C.tu++;
                }
                pa = pa->right;
                pb = pb->right;
            }
            else if (pa->j < pb->j)
            {
                insert(C, pa->i, pa->j, pa->data);
                pa = pa->right;
                C.tu++;
            }
            else if (pa->j > pb->j)
            {
                insert(C, pb->i, pb->j, pb->data);
                pb = pb->right;
                C.tu++;
            }
        }
        while (pa)
        {
            insert(C, pa->i, pa->j, pa->data);
            pa = pa->right;
            C.tu++;
        }
        while (pb)
        {
            insert(C, pb->i, pb->j, pb->data);
            pb = pb->right;
            C.tu++;
        }
    }
}
void print(link& A)
{
    for (int i = 1; i <= A.mu; i++)
    {
        node* pa = A.r[i];
        while (pa)
        {
            cout << pa->i << " " << pa->j << " " << pa->data << endl;
            pa = pa->right;
        }
    }
}
int main()
{
    int m, n, t1, t2;
    cin >> m >> n >> t1 >> t2;
    link A, B, C;
    create(A, m, n, t1);
    create(B, m, m, t2);
    create(C, m, n, 0);
    int a, b, c;
    for (int i = 1; i <= t1; i++)
    {
        cin >> a >> b >> c;
        insert(A, a, b, c);
    }
    for (int i = 1; i <= t2; i++)
    {
        cin >> a >> b >> c;
        insert(B, a, b, c);
    }
    addmatrix(A, B, C);
    //cout << "A" << endl;
    //print(A);
    //cout << "B" << endl;
    //print(B);
    //cout << "C" << endl;
    print(C);
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
int max(int a, int b)
{
	if (a >= b)
		return a;
	else
		return b;
}
int main()
{
	string str;
	cin >> str;
	int maxdp1 = 0, maxdp2 = 0;
	//表头分析
	int dp = 0;
	for (int i = 0; i < str.size(); i++)
	{
		if (str[i] == '(')
		{
			dp++;
			maxdp1 = max(maxdp1, dp);
		}	
		if (str[i] == ')')
		{
			dp--;
		}
	}
	//表尾分析
	dp = 0;
	for (int j = str.size() - 1; j > -1; j--)
	{
		if (str[j] == ')')
		{
			dp++;
			maxdp2 = (maxdp2, dp);
		}
		if (str[j] == '(')
			dp--;
	}
	cout << maxdp1 << endl;
	cout << maxdp2 << endl;
	return 0;
}