1. 電路如何列出矩陣
當年第一次接觸到用矩陣來處理線方程時（就是大一的時候啦），就覺得矩陣這東西真有創意。 最近在為當年補課，在看麻省理工的公開課。當看到用矩陣來處理圖論這一課時，又給了我一些開啟。當然，這篇博客的主要內容也是參考的這一節課。
現在假設有一個電路如下。
X
其實有1,2,3,4四個結點。有5條邊（連線），都標上序號了。
現在用矩陣來表示這個圖。
這個矩陣有5行4列。其實就是對應上圖的5條連線4個結點。第一行表示的是第一條連線的信息，第1列為－1，第3列為1。表示這條連線是從結點1接連到結點3，這里用1或者－1來標記，可以區分是起點還是終點，加起來就相當於:終點－起點，很符合向量的思維形式（其實就是這點帶來後面的優勢，如果有權重的需求,先不急，你會發現這樣很值得）。
依此類推來理解第2行，第3行。。。
這個矩陣叫鄰接矩陣。用鄰接矩陣來表示這個電路是思路的關鍵。
我原來想到的是用一個4行4列的矩陣表示。例如對於上圖的第一條邊是從結點1到結點3的。我就在第1行，第3列打上1，或者是別的數（權重）。這樣的表示我自己也沒有看到多大的優勢。所以用矩陣解析這類問題的方法沒有太吸引我。
2. 在ROM存儲器中必須有什麼電路
rom是英文"read-only
memory"的簡稱,意思是只讀存儲器.其特點:是只能從該存儲器讀取數據,而不能向該存儲器寫數據,裡面已寫入的數據可長期保留.
3. c++利用鄰接矩陣存儲方法實現圖的存儲與輸出。
復制粘貼即可
#include <iostream>
using namespace std;
//*****stack.h
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
template<class QElemType>
class stack
{
public:
void InitStack();
void DestroyStack();
void ClearStack();
Status StackEmpty();
Status StackLength();
void GetTop(QElemType & e);
void Push(QElemType e);
void Pop(QElemType & e);
private:
struct SqStack{
QElemType *base;
QElemType *top;
int stacksize;
}S;
};
//******stack.cpp------
template<class QElemType>
void stack<QElemType>::InitStack()
{
S.base = (QElemType *)malloc(STACK_INIT_SIZE * sizeof(QElemType));
if(!S.base) exit(0);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
}
template <class QElemType>
void stack<QElemType>::DestroyStack()
{
free(S.base);
}
template <class QElemType>
void stack<QElemType>::ClearStack()
{
S.top = S.base;
}
template <class QElemType>
Status stack<QElemType>::StackEmpty()
{
if(S.top == S.base) return 1;
else return 0;
}
template <class QElemType>
Status stack<QElemType>::StackLength()
{
return (S.top - S.base);
}
template <class QElemType>
void stack<QElemType>::GetTop(QElemType & e)
{
if(S.top != S.base)
e = *(S.top - 1);
else cout << "ERROR" << endl;
}
template <class QElemType>
void stack<QElemType>::Push(QElemType e)
{
if(S.top - S.base >= S.stacksize)
{
S.base = (QElemType *)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(QElemType));
if(!S.base) exit(0);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
}
template <class QElemType>
void stack<QElemType>::Pop(QElemType & e)
{
if(S.top == S.base) cout << "ERROR" << endl;
else
e = * --S.top;
}
//**********stack.cpp End
template <class TElemType>
class Graph
{
public:
void CreateUDN();
void DestroyUDN();
void CreateAlgraph();
void DestroyAlgraph();
void DFS(int v,bool *visited);
void DFSTraverse();
void Minispantree_prim(); //PRIM演算法求最小生成樹
void Shortestpath_DIJ(TElemType data1,TElemType data2); //對環不適用，如從V1到V1就不適用
void Shortestpath_FLOYD(TElemType data1,TElemType data2);
private:
template <class TElemType>
struct Mgraph{
int vexnum;
int arcnum;
TElemType *vertex;
int **AdjMatrix;
};
Mgraph<TElemType> gph; //鄰接矩陣存儲
struct Arcnode
{
int adjvex;
Arcnode *nextarc;
float weight;
};
template <class TElemType>
struct Vexnode
{
TElemType data;
Arcnode *firarc;
};
struct ALgraph
{
int vexnum;
int arcnum;
bool kind;
Vexnode<TElemType> *vex;
};
ALgraph algraph; //鄰接表存儲
};
//*********Graph.cpp
template <class TElemType>
void Graph<TElemType>::CreateUDN()
{
cout << "輸入無向網的頂點數和邊數:" << endl;
cin >> gph.vexnum >> gph.arcnum;
gph.vertex = (TElemType *)malloc(gph.vexnum * sizeof(TElemType));
int i,j,m,n; //m,n表示頂點信息對應的序號，w是權值
int w;
TElemType v1,v2;
cout << "輸入頂點信息:" << endl;
for(i = 0;i < gph.vexnum;i++)
cin >> gph.vertex[i];
gph.AdjMatrix = (int **)malloc(gph.vexnum * sizeof(int *));
for(i = 0;i < gph.vexnum;i++)
gph.AdjMatrix[i] = (int *)malloc(gph.vexnum * sizeof(int));
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
gph.AdjMatrix[i][j] = INT_MAX; //INT_MAX
cout << "輸入一條邊依附的兩點及權值:" << endl;
for(int k = 0;k < gph.arcnum;k++)
{
cin >> v1 >> v2 >> w;
for(i = 0;i < gph.vexnum;i++)
{
if(v1 == gph.vertex[i]) m = i;
if(v2 == gph.vertex[i]) n = i;
}
gph.AdjMatrix[m][n] = gph.AdjMatrix[n][m] = w;
}
}
template <class TElemType>
void Graph<TElemType>::DestroyUDN()
{
free(gph.vertex);
for(int i = 0;i < gph.vexnum;i++)
free(gph.AdjMatrix[i]);
free(gph.AdjMatrix);
}
template <class TElemType>
void Graph<TElemType>::CreateAlgraph()
{
int i,j,m,n;
float w;
TElemType v1,v2;
Arcnode *p;
cout << "輸入圖類型（1是無向圖，0是有向圖):" << endl;
cin >> algraph.kind;
cout << "輸入頂點數和邊數:" << endl;
cin >> algraph.vexnum >> algraph.arcnum;
algraph.vex = (Vexnode<TElemType> *)malloc(algraph.vexnum * sizeof(Vexnode<TElemType>));
cout << "輸入頂點信息:" << endl;
for(i = 0;i < algraph.vexnum;i++)
{
cin >> algraph.vex[i].data;
algraph.vex[i].firarc = NULL;
}
if(algraph.kind)
{
cout << "輸入各邊依附的兩點和權值:" << endl;
for(i = 0;i < algraph.arcnum;i++)
{
cin >> v1 >> v2 >>w;
for(j = 0;j < algraph.vexnum;j++)
{
if(v1 == algraph.vex[j].data) m = j;
if(v2 == algraph.vex[j].data) n = j;
}
p = (Arcnode *)malloc(2*sizeof(Arcnode));
p[0].adjvex = n;p[0].weight = w;
p[1].adjvex = m;p[1].weight = w;
p[0].nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
p[1].nextarc = algraph.vex[n].firarc;algraph.vex[n].firarc = ++p;
}
}
else
{
cout << "輸入各邊的弧尾與弧頭結點及有向邊的權值:" << endl;
for(i = 0;i < algraph.arcnum;i++)
{
cin >> v1 >> v2 >> w;
for(j = 0;j < algraph.vexnum;j++)
{
if(v1 == algraph.vex[j].data) m = j;
if(v2 == algraph.vex[j].data) n = j;
}
p = (Arcnode *)malloc(sizeof(Arcnode));
p->adjvex = n;p->weight = w;
p->nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
}
}
} //構造完成
template <class TElemType>
void Graph<TElemType>::DestroyAlgraph()
{
int i;
Arcnode *p,*q;
for(i = 0;i < algraph.vexnum;i++)
{
p = algraph.vex[i].firarc;
if(p)
{
q = p->nextarc;
while(q)
{
free(p);
p = q;
q = q->nextarc;
}
free(p);
}
}
free(algraph.vex);
}
template <class TElemType>
void Graph<TElemType>::DFS(int v,bool *visited)
{
cout << algraph.vex[v].data << endl;
visited[v] = true;
Arcnode *p;
int v1;
for(p = algraph.vex[v].firarc;p;p = p->nextarc)
{
v1 = p->adjvex;
if(!visited[v1]) DFS(v1,visited);
}
}
template <class TElemType>
void Graph<TElemType>::DFSTraverse()
{
int i,v;
bool *visited = (bool *)malloc(algraph.vexnum * sizeof(bool));
for(i = 0;i < algraph.vexnum;i++)
visited[i] = false;
for(v = 0;v < algraph.vexnum;v++)
if(!visited[v]) DFS(v,visited);
free(visited);
} //EndDFSTraverse
template <class TElemType>
void Graph<TElemType>::Minispantree_prim()
{
struct closedge
{
int adjvex;
int lowcost;
};
closedge *edge = (closedge *)malloc(gph.vexnum * sizeof(closedge));
int i,j,k = 0,u;
int min;
for(i = 0;i < gph.vexnum;i++)
{
if(i != k)
{
edge[i].adjvex = 0;
edge[i].lowcost = gph.AdjMatrix[k][i];
}
}
edge[k].lowcost = 0;
cout << "最小生成樹的邊如下:" << endl;
for(i = 1;i < gph.vexnum;i++)
{
min = INT_MAX;
for(j = 0;j < gph.vexnum;j++)
if(edge[j].lowcost != INT_MAX &&edge[j].lowcost != 0 && edge[j].lowcost < min)
{
min = edge[j].lowcost;
k = j;
}
u = edge[k].adjvex;
edge[k].lowcost = 0;
cout << "(" << gph.vertex[u] << "," << gph.vertex[k] << ")" << " ";
for(j = 0;j < gph.vexnum;j++)
if(gph.AdjMatrix[j][k] < edge[j].lowcost)
{
edge[j].lowcost = gph.AdjMatrix[j][k];
edge[j].adjvex = k;
}
}
free(edge);
cout << endl;
}
template <class TElemType>
void Graph<TElemType>::Shortestpath_DIJ(TElemType data1,TElemType data2)
{
int i,j,v,u,k,min;
stack<int> S;
S.InitStack();
int *spath = (int *)malloc(gph.vexnum * sizeof(int));
int *pathrecord = (int *)malloc(gph.vexnum * sizeof(int));
bool *visited = (bool *)malloc(gph.vexnum * sizeof(bool));
for(i = 0;i < gph.vexnum;i++) visited[i] = false;
for(i = 0;i < gph.vexnum;i++)
{
if(data1 == gph.vertex[i]) v = i;
if(data2 == gph.vertex[i]) u = i;
}
for(i = 0;i < gph.vexnum;i++)
{
spath[i] = gph.AdjMatrix[v][i];
pathrecord[i] = v;
}
spath[v] = 0;visited[v] = true;pathrecord[v] = -1;
for(i = 1;i < gph.vexnum;i++)
{
min = INT_MAX;
for(j = 0;j < gph.vexnum;j++)
{
if(!visited[j])
{
if(spath[j] < min) {min = spath[j];k = j;}
}
}
visited[k] = true;
for(j = 0;j < gph.vexnum;j++)
if(!visited[j] && gph.AdjMatrix[k][j] < INT_MAX && spath[k]+gph.AdjMatrix[k][j] < spath[j])
{
spath[j] = spath[k]+gph.AdjMatrix[k][j];
pathrecord[j] = k;
}
}
free(visited);
cout << spath[u] << endl;
S.Push(u);
for(v = pathrecord[u];v != -1;v = pathrecord[v])
S.Push(v);
while(!S.StackEmpty())
{
S.Pop(i);
cout << gph.vertex[i] << " ";
}
cout << endl;
S.DestroyStack();
free(spath);
free(pathrecord);
}
template <class TElemType>
void Graph<TElemType>::Shortestpath_FLOYD(TElemType data1,TElemType data2)
{
int i,j,k,v,u,m;
int **D = (int **)malloc(gph.vexnum * sizeof(int *));
bool ***path = (bool ***)malloc(gph.vexnum * sizeof(bool **));
for(i = 0;i < gph.vexnum;i++)
{
D[i] = (int *)malloc(gph.vexnum * sizeof(int));
path[i] = (bool **)malloc(gph.vexnum * sizeof(bool *));
if(data1 == gph.vertex[i]) v = i;
if(data2 == gph.vertex[i]) u = i;
}
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
path[i][j] = (bool *)malloc(gph.vexnum *sizeof(bool));
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
{
D[i][j] = gph.AdjMatrix[i][j];
for(k = 0;k < gph.vexnum;k++)
path[i][j][k] = false;
if(D[i][j] < INT_MAX)
{
path[i][j][i] = true;path[i][j][j] = true;
}
}
for(k = 0;k < gph.vexnum;k++)
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
if(D[i][k] != INT_MAX && D[k][j] != INT_MAX && D[i][k]+D[k][j] < D[i][j])
{
D[i][j] = D[i][k] + D[k][j];
for(m = 0;m < gph.vexnum;m++)
path[i][j][m] = path[i][k][m] || path[k][j][m];
}
cout << "從" << gph.vertex[v] << "到" << gph.vertex[u] << "的最短路徑及經過的點如下:" << endl;
cout << D[v][u] << endl;
for(i = 0;i < gph.vexnum;i++)
if(path[v][u][i] == true) cout << i << " ";
cout << endl;
for(i = 0;i < gph.vexnum;i++)
{
free(D[i]);
free(path[i]);
}
free(D);
free(path);
}
//***********end Graph
int main()
{
Graph<int> gph;
gph.CreateUDN();
gph.Minispantree_prim();
int data1,data2;
cout << "輸入起點和終點:" << endl;
cin >> data1 >> data2;
gph.Shortestpath_DIJ(data1,data2);
//gph.Shortestpath_FLOYD(data1,data2);
gph.DestroyUDN();
return 0;
}
功能函數都實現了，可以自己在源程序中調用函數實現各種功能。
4. C語言對矩陣的存儲與讀取如何進行
這個要你自己實現一個串化和反串化的類。Mfc你可以使用Archive對象做，c的話要自己實現過程。
5. 矩陣的電路原理
切換原理上就是選擇，選擇的方式有很多種，最簡單的就是 將信號線直接接在一起，比如接線板，利用人工將輸出信號線跳接在輸入信號線上，也可完成選擇，或利用琴鍵開關完成接通與斷開，當然這是人工操作的，機械的，不存在指標等技術問題，故不作為矩陣切換討論。第二種方式，利用繼電器也可完成選擇，利用電平控制繼電器的通斷，可完成輸出線與輸入信號之間的斷開與聯接，也可完成信號的選擇，第三種方式是根據電路原理，利用晶元內部電路的導通與關閉進行接通與關斷，並可通過電平進行控制完成信號的選擇。
繼電器方式與晶元方式各有優缺點。
繼電器方式：如果不考慮輸入匹配與輸出驅動的電路部分的話，它與聯線方式一致，是靠物理接觸進行接通與斷開，從這個角度上講，是沒有什麼指標概念的(最多有接觸電阻和反應時間)，因此技術指標好且價格低廉，其缺點在於穩定性較差，畢竟是靠物理接觸，繼電器有一定壽命，原則上講，有8萬次平均無故障操作且操作時有聲響，由於線路板走線原因，不能做的規模較大，顯得不夠高檔。
晶元方式：由於靠電路進行接通與關斷，晶元本身存在技術指標(在輸入匹配與輸出驅動一樣的情況下)，因此要保障技術指標，就要選擇專用的切換晶元，因此價格較高，但穩定性好，可形成的矩陣規模較大。
矩陣切換應保證的技術指標
矩陣切換器根據不同的應用領域，所要求的技術指標也不同。以廣電行業為例，為保證終端的顯示質量，廣電行業將整個信號傳輸過程，從攝像頭開始到電視機為止，都進行了技術指標分配，對模擬矩陣切換和分配，所定的技術指標如表：GB/T14236-93與本公司KT-128*32實例指標：
6. 靜態RAM基本存儲電路
那個T3，T4是有源負載，相當於電阻，T3是T1的負載電阻，T4是T2的負載電阻，都是導通的，為T1，T2提供漏極電壓的。而真正導通和截止形成反相的，有兩個穩定狀態的是T1，T2。因為在集成電路內部不方便做電阻，所以，就用這種電路做電阻了。
7. 用存儲器見組成內存時，為什麼總是採用矩陣形式
存儲器分類 存儲器是計算機系統中的記憶設備，用來存放程序和數據。
構成存儲器的存儲介質，目前主要採用半導體器件和磁性材料。存儲器中最小的存儲單位就是一個雙穩態半導體電路或一個CMOS晶體管或磁性材料的存儲元，它可存儲一個二進制代碼。由。
8. 存儲電路是如何工作的
存儲器分為RAM(數據存儲器)和ROM（程序存儲器），他們工作原理都是一樣的，即實現對電平0和1的存儲。
存儲電路的工作原理見下圖，你可以把它看懂用自己的語言描述出來，這樣你的報告就可以寫出來了，然後大規模的存儲電路集成起來可以構成存儲器。
如果是應付寫報告，我給你概括下吧，存儲電路的工作原理是：存儲電路是把送來的地址信號通過地址解碼電路，在存儲矩陣中選中相應的存儲單元，將該單元存儲的數據送到輸出埠，為了實現存儲器的擴展往往在存儲器上加使能信號EN.大規模的存儲電路集成封裝起來就組成存儲器。
9. A是原始矩陣 求它的轉置矩陣，還是放在A里輸出 （要求：只能用一個存儲變數）
業務組合規劃工具，用於多業務公司的整體發展戰略 - 定向政策矩陣（DPM），是由荷蘭皇家殼牌集團開發。與一般的矩陣來選擇不同的量化指標，定向政策矩陣更直接地精的業務組合，並以達到真實性的商業區採取星級評定的方式可以量化的指標進行比較。
特點是只在：
我們1，矩陣是？ - 三經三矩陣，描繪了公司的競爭力和企業的發展前景;有限公司2，定位每一個企業都採取了一些變數，方法類似於通用電氣公司A中的競爭地位 - 市場吸引力矩陣
3，初次使用的技術細節特別適用於石化行業，但這種模式也廣泛適用於任何多元化的客戶
4，這是基於對業務增長和提前時間為基礎的新的生產。
頁5，指導性政策矩陣是？本質上是外部環境和內部環境歸結在一起下來，並做出判斷，其中企業的戰略地位，並提出了指導性的戰略規劃。
10. 簡述存儲器和寄存器在電路結構和工作原理上有何不同
存儲器是能存儲大量二值信息的半導體器件，它由地址解碼器、存儲矩陣、輸入/輸出電路三部分組成；每個存儲單元不直接引出輸入/輸出端，採用公共輸入/輸出匯流排結構。
寄存器是用於寄存一組二值代碼（信息），由時鍾觸發器組成；每個存儲單元直接引出輸入/輸出端。