Flow Graph
A flow graph is a graphical representation of a program that shows the control flow of the program. It consists of basic blocks and their successor relationships. Each basic block represents a sequence of instructions without any jump or branch instructions. The successor relationships indicate the possible paths of execution from one basic block to another.

Basic Blocks
Before understanding the flow graph, let's first understand what basic blocks are. A basic block is a straight-line sequence of instructions in a program that has only one entry point at the beginning and only one exit point at the end. It is a sequence of instructions that are always executed together, without any conditional or unconditional jumps in between.

Flow Graph Representation
A flow graph represents the control flow of a program using nodes and edges. Each basic block is represented by a node in the graph, and the edges between the nodes represent the successor relationships. The edges indicate the possible control flow paths from one basic block to another.

Example
Let's consider a simple example to understand the flow graph representation. Suppose we have the following code:

```
1. int a = 5;
2. int b = 10;
3. int c = a + b;
4. if (c > 15) {
5. c = c - 10;
6. } else {
7. c = c + 10;
8. }
9. int d = c * 2;
```

The basic blocks in this code would be:
- Basic Block 1: Instructions 1 and 2
- Basic Block 2: Instruction 3
- Basic Block 3: Instructions 4, 5, and 6
- Basic Block 4: Instructions 7 and 8
- Basic Block 5: Instruction 9

The flow graph representation of this code would be:
- Node 1: Basic Block 1
- Node 2: Basic Block 2
- Node 3: Basic Block 3
- Node 4: Basic Block 4
- Node 5: Basic Block 5

Edges:
- Edge from Node 1 to Node 2
- Edge from Node 2 to Node 3
- Edge from Node 2 to Node 4
- Edge from Node 3 to Node 5
- Edge from Node 4 to Node 5

Conclusion
In conclusion, the graph that shows basic blocks and their successor relationship is called a flow graph. It represents the control flow of a program using nodes and edges, where each basic block is represented by a node and the edges indicate the possible paths of execution from one basic block to another.